def do_open_administrator(server_instance):
validate_setting(server_instance.serverInfo, "sys.usesudo", norm_to_switch,
None) #"Server profile has no indication of sudo usage")
validate_setting(server_instance.serverInfo, "sys.usesudostatus",
norm_to_switch, None)
if server_instance.serverInfo["sys.system"] != "Windows":
#validate_setting(server_instance.serverInfo, "sys.sudo", make_str_existing, "Server profile has no privileges elevation command defined")
#if server_instance.serverInfo.has_key("sys.sudo") and server_instance.serverInfo["sys.sudo"].strip(" \r\t\n") == "":
# Utilities.show_warning("WB Administrator", "Server profile has empty privileges elevation command defined. Some functionality maybe unavailable", "OK", "", "")
try:
if not server_instance.serverInfo["sys.sudo"]:
# don't break settings that were working perfectly before, assume a valid default
server_instance.serverInfo[
"sys.sudo"] = "/usr/bin/sudo -p EnterPasswordHere /bin/bash -c"
except:
server_instance.serverInfo[
"sys.sudo"] = "/usr/bin/sudo -p EnterPasswordHere /bin/bash -c"
app = App.get()
try:
adminTab = AdministratorTab(server_instance)
except wb_admin_ssh.ConnectionError, exc:
Utilities.show_error(
"Error Connecting to Server (%s@%s)" %
(server_instance.loginInfo["ssh.userName"],
server_instance.loginInfo["ssh.hostName"]), str(exc), "OK", "",
"")
app.set_status_text("Could not Open WB Admin")
return None
def csvDataDictionary(catalog):
csvOut = ""
filechooser = FileChooser(mforms.OpenDirectory)
filechooser.set_extensions("CSV File (*.csv)", "csv")
if filechooser.run_modal():
csvOut = filechooser.get_path()
print "CSV File: %s" % (csvOut)
if len(csvOut) <= 1:
return 1
# iterate through columns from schema
schema = catalog.schemata[0]
for table in schema.tables:
csvFile = open("%s/%s.csv" % (csvOut, table.name), "w")
print >> csvFile, "Name,Data Type,Nullable,PK,FK,Reference,Default,Comment"
fks = table.foreignKeys
for column in table.columns:
pk = ('No', 'Yes')[bool(table.isPrimaryKeyColumn(column))]
is_fk = bool(table.isForeignKeyColumn(column))
fk = ('No', 'Yes')[is_fk]
ref = find_referenced_table(fks, column) if is_fk else ''
nn = ('No', 'Yes')[bool(column.isNotNull)]
print >> csvFile, "%s,\"%s\",%s,%s,%s,%s,\"%s\",%s" % (
column.name, column.formattedType, nn, pk, fk, ref,
column.defaultValue, column.comment)
Utilities.show_message(
"CSVs generated", "CSV data dictionaries from current model generated",
"OK", "", "")
return 0
def async_stop_finished(
self, status
): # status can be one of success, bad_password or error message
if status == "success":
self.print_output("Server stop done.")
elif status == "bad_password":
r = Utilities.show_error(
"Stop Server",
"A permission error occurred while attempting to stop the server.\n"
"Administrator password was possibly wrong.", "Retry",
"Cancel", "")
if r == mforms.ResultOk:
self.server_control.stop_async(self.async_stop_callback)
return
else:
self.print_output("Could not stop server. Permission denied")
else:
self.print_output("Could not stop server: %s" %
(status or "unknown error"))
Utilities.show_error("Could not stop server", str(status), "OK",
"", "")
self.refresh()
self.refresh_button.set_enabled(True)
self.start_stop_btn.set_enabled(True)
self.print_new_error_log_entries()
def _acquire_admin_access(self):
if not self._validate_remote_admin_settings():
self.admin_access_status = "Remote management settings are invalid"
return
while True:
try:
mforms.App.get().set_status_text(
"Acquiring management access to target host...")
self.ctrl_be.acquire_admin_access()
mforms.App.get().set_status_text(
"Management support for target host enabled successfully.")
return True
except wb_admin_ssh.ConnectionError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nSSH connection could not be established\n\n%s" % str(
exc)
Utilities.show_error(
"Error opening SSH connection to server (%s@%s)" %
(self.instance_profile.loginInfo["ssh.userName"],
self.instance_profile.loginInfo["ssh.hostName"]),
str(exc), "OK", "", "")
return None
except OperationCancelledError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nSSH connection was cancelled"
mforms.App.get().set_status_text(
"Cancelled SSH connection (%s)" % exc)
return None
def do_open_administrator(server_instance):
validate_setting(
server_instance.serverInfo, "sys.usesudo", norm_to_switch, None
) # "Server profile has no indication of sudo usage")
validate_setting(server_instance.serverInfo, "sys.usesudostatus", norm_to_switch, None)
if server_instance.serverInfo["sys.system"] != "Windows":
# validate_setting(server_instance.serverInfo, "sys.sudo", make_str_existing, "Server profile has no privileges elevation command defined")
# if server_instance.serverInfo.has_key("sys.sudo") and server_instance.serverInfo["sys.sudo"].strip(" \r\t\n") == "":
# Utilities.show_warning("WB Administrator", "Server profile has empty privileges elevation command defined. Some functionality maybe unavailable", "OK", "", "")
try:
if not server_instance.serverInfo["sys.sudo"]:
# don't break settings that were working perfectly before, assume a valid default
server_instance.serverInfo["sys.sudo"] = "/usr/bin/sudo -p EnterPasswordHere /bin/bash -c"
except:
server_instance.serverInfo["sys.sudo"] = "/usr/bin/sudo -p EnterPasswordHere /bin/bash -c"
app = App.get()
try:
adminTab = AdministratorTab(server_instance)
except wb_admin_ssh.ConnectionError, exc:
Utilities.show_error(
"Error Connecting to Server (%s@%s)"
% (server_instance.loginInfo["ssh.userName"], server_instance.loginInfo["ssh.hostName"]),
str(exc),
"OK",
"",
"",
)
app.set_status_text("Could not Open WB Admin")
return None
def selectServer(title):
# No need to select an instance if there's only one:
if len(grt.root.wb.rdbmsMgmt.storedInstances) == 1:
return grt.root.wb.rdbmsMgmt.storedInstances[0]
window = mforms.Form(None)
window.set_title(title)
box = mforms.newBox(False)
window.set_content(box)
box.set_padding(12)
box.set_spacing(12)
label = mforms.newLabel()
label.set_text("Select Server to Connect to:")
box.add(label, False, True)
listbox = mforms.newListBox(False)
box.add(listbox, True, True)
listbox.show()
for inst in grt.root.wb.rdbmsMgmt.storedInstances:
listbox.add_item(inst.name)
if len(grt.root.wb.rdbmsMgmt.storedInstances) > 0:
listbox.set_selected(0)
else:
Utilities.show_warning(
"No Database Server Instances",
"""You have not defined a database server instance. At least one
server instance is needed. Please define one by clicking in
"New Server Instance" and retry.""",
"OK",
"",
"",
)
return None
bbox = mforms.newBox(True)
box.add(bbox, False, True)
bbox.set_spacing(8)
ok = mforms.newButton()
ok.set_text("OK")
bbox.add_end(ok, False, True)
cancel = mforms.newButton()
cancel.set_text("Cancel")
bbox.add_end(cancel, False, True)
window.set_size(400, 300)
window.center()
if window.run_modal(ok, cancel):
i = listbox.get_selected_index()
if i >= 0:
return grt.root.wb.rdbmsMgmt.storedInstances[i]
return None
def create_ui(self):
self.loading = True
self.cfg_be = wb_admin_config_file_be.WbAdminConfigFileBE(self.server_profile, self.ctrl_be)
sys_config_path = self.server_profile.config_file_path
if sys_config_path is None:
sys_config_path = ""
self.file_name_ctrl.set_value(sys_config_path)
self.section_ctrl.add_changed_callback(self.clear_and_load)
try:
self.myopts = self.cfg_be.get_possible_options()
option_stats = self.cfg_be.get_option_set_stats()
dprint_ex(1, "Options stats: '%s'" % str(option_stats))
if option_stats and type(option_stats) is dict:
added = option_stats.get("added", None)
if added is not None and added < 10:
user_selected_version = run_version_select_form(option_stats["version"])
self.server_profile.set_server_version(".".join(map(lambda x: str(x), user_selected_version)))
self.cfg_be.reload_possible_options()
self.myopts = self.cfg_be.get_possible_options()
option_stats = self.cfg_be.get_option_set_stats()
dprint_ex(1, "Options stats after version correction: '%s'" % str(option_stats))
except KeyError:
Utilities.show_error("Error", "Wrong version '" + self.version + "'given to admin plugin", "Close", None, None)
self.load_options_from_cfg()
#build ordered list of pages. Initially only skeleton pages are created, means only names.
# Values into pages will be load as soon as page is switched to.
self.pages = {}
for page_name, page_content in self.myopts.iteritems():
self.pages[int(page_content['position'])] = Page(page_name, page_content) # False means page not created
# page key is its position in UI. As we can have pages positions set like (1,2,4,5)
# the position set needs to be sorted so pages appear in specified order
page_positions = self.pages.keys()
page_positions.sort()
# Create dummy pages according to assigned position
for page_pos in page_positions:
page = self.pages[page_pos]
page.panel = newScrollPanel(mforms.ScrollPanelNoFlags)
self.tab_view.add_page(page.panel, page.page_name)
if debug_level > 0:
# Create file page
page = Page("File", None)
page.panel = newTextBox(mforms.BothScrollBars)
page.set_update_cb(self.update_file_content_tab)
self.pages[max(self.pages.keys()) + 1] = page
self.tab_view.add_page(page.panel, page.page_name)
# Create first page, so we display something from start
self.create_page(1)
self.loading = True # create_page resets loading flag
self.tab_view.add_tab_changed_callback(self.tab_changed)
self.loading = False
def update_refresh_rate(self):
index = int(self.refresh_selector.get_selected_index())
grt.root.wb.options.options[
'Administrator:refresh_connections_rate_index'] = index
self.serial += 1
if (index < self.refresh_values_size):
Utilities.add_timeout(self.refresh_values[index],
partial(self.refresh, my_serial=self.serial))
def validate_setting(settings, option, norm_cb, msg):
if settings.has_key(option):
if norm_cb is not None:
norm_cb(settings, option)
else:
if msg is not None:
Utilities.show_warning("WB Administrator", msg, "OK", "", "")
norm_cb(settings, option)
def validate_setting(settings, option, norm_cb, msg):
if settings.has_key(option):
if norm_cb is not None:
norm_cb(settings, option)
else:
if msg is not None:
Utilities.show_warning("WB Administrator", msg, "OK", "", "")
norm_cb(settings, option)
def start_stop_clicked(self):
try:
self.start_error_log_tracking()
except OperationCancelledError:
# we could abort everything if we knew that start/stop server also needs sudo password
# to avoid user having to cancel that twice, but since we're not sure if the start/stop will
# indeed require the sudo password, we can't give up yet
pass
status = self.ctrl_be.is_server_running(verbose=1)
# Check if server was started/stoped from outside
if self.is_server_running_prev_check == status:
if status == "running" or status == "offline":
if status == "offline":
self.print_output("Server is in offline mode.")
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
try:
if self.server_control and not self.server_control.stop_async(
self.async_stop_callback, True):
if self.ctrl_be.target_version and self.ctrl_be.target_version.is_supported_mysql_version_at_least(
5, 7, 5):
self.offline_mode_btn.show(True)
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
if self.ctrl_be.target_version and self.ctrl_be.target_version.is_supported_mysql_version_at_least(
5, 7, 5):
self.offline_mode_btn.show(True)
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error(
"Stop Server",
"An error occurred while attempting to stop the server.%s %s\n"
% (type(exc).__name__, exc), "OK", "", "")
return
elif status == "stopped":
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
self.offline_mode_btn.set_enabled(False)
try:
if self.server_control and not self.server_control.start_async(
self.async_start_callback, True):
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error(
"Start Server",
"An error occurred while attempting to start the server.%s %s\n"
% (type(exc).__name__, exc), "OK", "", "")
return
def commit(self):
if self._selected_user:
try:
self._selected_user.save()
except PermissionDeniedError, exc:
Utilities.show_error("Save Account Changes", str(exc), "OK",
"", "")
return
self.unset_dirty()
def update_refresh_rate(self):
index = int(self.refresh_selector.get_selected_index())
grt.root.wb.options.options['Administrator:refresh_connections_rate_index'] = index
self.serial += 1
if self._refresh_timeout:
Utilities.cancel_timeout(self._refresh_timeout)
self._refresh_timeout = None
if (index < self.refresh_values_size):
self._refresh_timeout = Utilities.add_timeout(self.refresh_values[index], partial(self.refresh, my_serial = self.serial))
def generateCSVDataDictionary(catalog):
#choose a file name for the data dictionary
fileName = ""
fileChooser = FileChooser(mforms.SaveFile)
fileChooser.set_extensions("CSV File (*.csv)|*.csv", "csv")
if fileChooser.run_modal():
fileName = fileChooser.get_path()
#static headers
headers = [
'Schema', 'Table', 'Name', 'Data Type', 'Nullable', 'PK', 'FK',
'Default', 'Description', 'Sample Data'
]
#create and open the csv file
with open(fileName, 'wb') as csvfile:
#create a csv writer
csvWriter = csv.writer(csvfile)
#write the headers into the csv file
csvWriter.writerow(headers)
#start of schema iteration
for schema in catalog.schemata:
#start of tables iteration
for table in schema.tables:
#start of columns iteration
for column in table.columns:
isPrimaryKey = ('No', 'Yes')[bool(
table.isPrimaryKeyColumn(column))]
isForeignKey = ('No', 'Yes')[bool(
table.isForeignKeyColumn(column))]
isNotNullable = ('No', 'Yes')[bool(column.isNotNull)]
#write the values in a row in the csv file
csvWriter.writerow([
schema.name, table.name, column.name,
column.formattedType, isNotNullable, isPrimaryKey,
isForeignKey, column.defaultValue
])
#end of columns iteration
#end of tables iteration
#end of schema iteration
#show message for a successful generation of data dictionary
Utilities.show_message("Data dictionary generated",
"CSV format data dictionary generated", "OK", "",
"")
return 0
def GenerateDrupalSchema(catalog):
output = ''
# Add all schema.
for schema in catalog.schemata :
hook_created = False
comment_replace = {}
# Collect the comment replacement strings.
for table in schema.tables :
comment_replace[(' %s table ' % table.name)] = ' {%s} table ' % table.name
comment_replace[(' %s table.' % table.name)] = ' {%s} table.' % table.name
for column in table.columns :
comment_replace[(' %s.%s ' % (table.name, column.name))] = ' {%s}.%s ' % (table.name, column.name)
comment_replace[(' %s.%s.' % (table.name, column.name))] = ' {%s}.%s.' % (table.name, column.name)
# Add all tables.
for table in schema.tables :
if len(table.columns) > 0 :
if not hook_created :
''' Create the hook '''
if len(output) > 0 :
output += "\n\n"
output += "/**\n"
output += " * Implements hook_schema().\n"
output += " */\n"
output += "function %s_schema() {\n" % re.sub(r'([^a-z0-9_]+|^[^a-z]+)', '', schema.name.lower().replace(' ', '_'))
output += " $schema = array();\n\n"
hook_created = True
''' Add the table '''
output += generateTableDefinition(table, comment_replace)
output += "\n"
if hook_created :
''' Close the hook '''
output += " return $schema;\n"
output += '}'
if len(output) > 0 :
# Should the output be copied to the clipboard?
answer = Utilities.show_message('Copy to clipboard?', "Would you like to copy the schema to your clipboard?\nIt can also be viewed in the output window.", 'Yes', 'No', '')
if answer == mforms.ResultOk :
grt.modules.Workbench.copyToClipboard(output)
# MySQL specific fields warning.
if "'mysql_type' => '" in output :
Utilities.show_message('MySQL specific fields used', 'Note that the schema definition contains MySQL specific fields!', 'OK', '', '')
print output
else :
Utilities.show_warning('No valid tables found', 'The schema was not generated because no valid tables were found.', 'OK', '', '')
return 0
def _sidebar_entry_clicked(self, entry_id):
if entry_id == "configure":
openConnectionSettings(self.editor)
else:
if entry_id in self.disabled_pages:
Utilities.show_error(self.page_titles[entry_id],
self.disabled_pages[entry_id], "OK", "",
"")
return
self.open_into_section(entry_id)
def _sidebar_entry_clicked(self, entry_id):
if entry_id == "configure":
openConnectionSettings(self.editor)
else:
if entry_id in self.disabled_pages:
Utilities.show_error(self.page_titles[entry_id],
self.disabled_pages[entry_id],
"OK", "", "")
return
self.open_into_section(entry_id)
def selectServer(title):
# No need to select an instance if there's only one:
if len(grt.root.wb.rdbmsMgmt.storedInstances) == 1:
return grt.root.wb.rdbmsMgmt.storedInstances[0]
window = mforms.Form(None)
window.set_title(title)
box = mforms.newBox(False)
window.set_content(box)
box.set_padding(12)
box.set_spacing(12)
label = mforms.newLabel()
label.set_text("Select Server to Connect to:")
box.add(label, False, True)
listbox = mforms.newListBox(False)
box.add(listbox, True, True)
listbox.show()
for inst in grt.root.wb.rdbmsMgmt.storedInstances:
listbox.add_item(inst.name)
if len(grt.root.wb.rdbmsMgmt.storedInstances) > 0:
listbox.set_selected(0)
else:
Utilities.show_warning(
"No Database Server Instances",
'''You have not defined a database server instance. At least one
server instance is needed. Please define one by clicking in
"New Server Instance" and retry.''', "OK", "", "")
return None
bbox = mforms.newBox(True)
box.add(bbox, False, True)
bbox.set_spacing(8)
ok = mforms.newButton()
ok.set_text("OK")
bbox.add_end(ok, False, True)
cancel = mforms.newButton()
cancel.set_text("Cancel")
bbox.add_end(cancel, False, True)
window.set_size(400, 300)
window.center()
if window.run_modal(ok, cancel):
i = listbox.get_selected_index()
if i >= 0:
return grt.root.wb.rdbmsMgmt.storedInstances[i]
return None
def commit(self):
if self._selected_user:
username = self.username.get_string_value()
host = self.hostlimithost.get_string_value()
is_new_user = not self._selected_user.is_commited
password_unneeded = False
if self.has_extra_plugins and not AUTHENTICATION_PLUGIN_TYPES[
self.selected_plugin_type()]["enable_password"]:
password_unneeded = True
if is_new_user and not self.password.get_string_value(
) and not password_unneeded:
if Utilities.show_warning(
"Save Account Changes",
"It is a security hazard to create an account with no password.\nPlease confirm creation of '%s'@'%s' with no password."
% (username, host), "Create", "Cancel",
"") != mforms.ResultOk:
return
self._selected_user.username = self.username.get_string_value()
self._selected_user.password = self.password.get_string_value()
self._selected_user.confirm_password = self.confirm.get_string_value(
)
#if self.hostlimit.get_active():
self._selected_user.host = self.hostlimithost.get_string_value()
# else:
# self._selected_user.host = "%"
self._selected_user.max_questions = int(
self.max_questions.get_string_value())
self._selected_user.max_updates = int(
self.max_updates.get_string_value())
self._selected_user.max_connections = int(
self.max_connections.get_string_value())
self._selected_user.max_user_connections = int(
self.max_uconnections.get_string_value())
if is_new_user and self.has_extra_plugins:
self._selected_user.auth_plugin = self.selected_plugin_type()
if self._selected_user.auth_plugin:
self._selected_user.auth_string = self.auth_string_param.get_string_value(
)
try:
self._selected_user.save()
except WBSecurityValidationError, exc:
Utilities.show_error("Save Account Changes", str(exc), "OK",
"", "")
return
except PermissionDeniedError, exc:
Utilities.show_error("Save Account Changes", str(exc), "OK",
"", "")
return
def _dock_admin_tab(self):
app = mforms.App.get()
try:
self.ctrl_be = wb_admin_control.WbAdminControl(self.server_profile, self.editor, connect_sql=True)
self.ctrl_be.init()
self.admin_tab = wb_admin_main.AdministratorTab(self.ctrl_be, self.server_profile, self, self.editor)
except MySQLError, exc:
if exc.message:
Utilities.show_error("Error Connecting to MySQL Server (%s)" % exc.location, str(exc), "OK", "", "")
app.set_status_text("Could not Open WB Admin")
return None
def create_ui(self):
self.loading = True
self.cfg_be = wb_admin_config_file_be.WbAdminConfigFileBE(
self.server_profile, self.ctrl_be)
sys_config_path = self.server_profile.config_file_path
if sys_config_path is None:
sys_config_path = ""
self.file_name_ctrl.set_value(sys_config_path)
self.section_ctrl.add_changed_callback(self.clear_and_load)
try:
self.myopts = self.cfg_be.get_possible_options()
except KeyError:
Utilities.show_error(
"Error",
"Wrong version '" + self.version + "'given to admin plugin",
"Close", None, None)
self.load_options_from_cfg()
#build ordered list of pages. Initially only skeleton pages are created, means only names.
# Values into pages will be load as soon as page is switched to.
self.pages = {}
for page_name, page_content in self.myopts.iteritems():
self.pages[int(page_content['position'])] = Page(
page_name, page_content) # False means page not created
# page key is its position in UI. As we can have pages positions set like (1,2,4,5)
# the position set needs to be sorted so pages appear in specified order
page_positions = self.pages.keys()
page_positions.sort()
# Create dummy pages according to assigned position
for page_pos in page_positions:
page = self.pages[page_pos]
page.panel = newScrollPanel(mforms.ScrollPanelNoFlags)
self.tab_view.add_page(page.panel, page.page_name)
if debug_level > 0:
# Create file page
page = Page("File", None)
page.panel = newTextBox(mforms.BothScrollBars)
page.set_update_cb(self.update_file_content_tab)
self.pages[max(self.pages.keys()) + 1] = page
self.tab_view.add_page(page.panel, page.page_name)
# Create first page, so we display something from start
self.create_page(1)
self.loading = True # create_page resets loading flag
self.tab_view.add_tab_changed_callback(self.tab_changed)
self.loading = False
def _dock_admin_tab(self):
app = mforms.App.get()
try:
self.ctrl_be = wb_admin_control.WbAdminControl(self.server_profile, connect_sql=True)
self.ctrl_be.init()
self.admin_tab = wb_admin_main.AdministratorTab(self.ctrl_be, self.server_profile, self, self.editor)
except MySQLError, exc:
if exc.message:
Utilities.show_error("Error Connecting to MySQL Server (%s)" % exc.location, str(exc), "OK", "", "")
app.set_status_text("Could not Open WB Admin")
return None
def start_stop_clicked(self):
try:
self.start_error_log_tracking()
except OperationCancelledError:
# we could abort everything if we knew that start/stop server also needs sudo password
# to avoid user having to cancel that twice, but since we're not sure if the start/stop will
# indeed require the sudo password, we can't give up yet
pass
status = self.ctrl_be.is_server_running(verbose=1)
# Check if server was started/stoped from outside
if self.is_server_running_prev_check == status:
if status == "running" or status == "offline":
if status == "offline":
self.print_output("Server is in offline mode.")
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
try:
if self.server_control and not self.server_control.stop_async(self.async_stop_callback, True):
if self.ctrl_be.target_version and self.ctrl_be.target_version.is_supported_mysql_version_at_least(5, 7, 5):
self.offline_mode_btn.show(True)
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
if self.ctrl_be.target_version and self.ctrl_be.target_version.is_supported_mysql_version_at_least(5, 7, 5):
self.offline_mode_btn.show(True)
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error("Stop Server",
"An error occurred while attempting to stop the server.%s %s\n" % (type(exc).__name__, exc),
"OK", "", "")
return
elif status == "stopped":
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
self.offline_mode_btn.set_enabled(False)
try:
if self.server_control and not self.server_control.start_async(self.async_start_callback, True):
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error("Stop Server",
"An error occurred while attempting to stop the server.%s %s\n" % (type(exc).__name__, exc),
"OK", "", "")
return
def _check_server_version(self):
version = self.ctrl_be.get_server_version()
if type(version) is tuple:
valid_versions = ((4,0), (4,1), (5,0), (5,1), (5,2), (5,4), (5,5), (5,6), (5, 7))
if version[:2] not in valid_versions:
log_warning(_this_file, "%s: Server version %s is NOT supported\n" % (self.__class__.__name__, str(version)) )
Utilities.show_error("Unsupported Server Version", "The version of the server you're trying to connect to is %i.%i, which is not supported by Workbench."%version[:2],
"Close", "Ignore", "")
return False
else:
log_info(_this_file, "%s: Server version %s is supported\n" % (self.__class__.__name__, str(version)) )
return True
return None
def htmlDataDictionary(catalog):
# Put plugin contents here
mdOut = ""
filechooser = FileChooser(mforms.SaveFile)
filechooser.set_extensions("Markdown File (*.md)|*.md", "md")
if filechooser.run_modal():
mdOut = filechooser.get_path()
print "Markdown File: %s" % (mdOut)
if len(mdOut) <= 1:
return 1
# iterate through columns from schema
schema = catalog.schemata[0]
mdFile = open(mdOut, "w")
print >> mdFile, "# Diccionario de datos"
print >> mdFile, ""
tables = schema.tables
tables = sorted(tables, key=orderTables)
for table in tables:
print >> mdFile, "- [%s](#markdown-header-%s)" % (table.name,
table.name)
print >> mdFile, ""
for table in tables:
print >> mdFile, "## %s" % (table.name)
print >> mdFile, "%s" % (table.comment)
print >> mdFile, ""
print >> mdFile, "|Nombre|Tipo de dato|Nulo|PK|FK|Default|Comentario|"
print >> mdFile, "|------|------------|----|--|--|-------|----------|"
for column in table.columns:
pk = ('No', 'Yes')[bool(table.isPrimaryKeyColumn(column))]
fk = ('No', 'Yes')[bool(table.isForeignKeyColumn(column))]
nn = ('No', 'Yes')[bool(column.isNotNull)]
print >> mdFile, "|%s|%s|%s|%s|%s|%s|%s|" % (
column.name, column.formattedType, nn, pk, fk,
column.defaultValue, column.comment.replace('\n', ''))
print >> mdFile, ""
print >> mdFile, "[Regresar al listado](#markdown-header-diccionario-de-datos)"
print >> mdFile, ""
print >> mdFile, ""
Utilities.show_message("Diccionario de datos creado",
"El archivo markdonw fue generado exitosamente",
"Aceptar", "", "")
return 0
def htmlDataDictionary(catalog):
htmlOut = ""
filechooser = FileChooser(mforms.SaveFile)
filechooser.set_extensions("HTML File (*.html)|*.html", "html")
if filechooser.run_modal():
htmlOut = filechooser.get_path()
print "HTML File: %s" % (htmlOut)
if len(htmlOut) <= 1:
return 1
# iterate through columns from schema
schema = catalog.schemata[0]
htmlFile = open(htmlOut, "w")
print >> htmlFile, "<html><head>"
print >> htmlFile, "<title>Schema Report for database: %s</title>" % (
schema.name)
print >> htmlFile, """<style>
td,th {
text-align:left;
vertical-align:middle;
border: 1px solid;
}
table {
border: none;
border-collapse: collapse;
}
td {
display: block;
float: left;
padding-left: 5px;
padding-right: 5px;
}
</style>
</head>
<body>"""
print >> htmlFile, "<h1>Schema Report for database: %s</h1>" % (
schema.name)
masters = [
"badge_categories", "camp_categories", "camp_procedures", "camps",
"organizations", "permissions", "programs", "provinces", "regions",
"religions", "roles", "schools", "users", "years"
]
print >> htmlFile, "<h1>Master</h1><br>"
draw(htmlFile, schema, masters, True)
print >> htmlFile, "<h1>Transaction</h1><br>"
draw(htmlFile, schema, masters, False)
print >> htmlFile, "</body></html>"
Utilities.show_message("Report generated",
"HTML Report format from current model generated",
"OK", "", "")
return 0
def handle_on_close(self):
log_debug("Closing admin\n")
if self._timeout_tm:
Utilities.cancel_timeout(self._timeout_tm)
self._timeout_tm = None
nc.remove_observer(self.handle_server_state_changed)
App.get().set_status_text("Closing Administator.")
self.shutdown()
if not self.closing:
log_debug("Admin close cancelled\n")
return False
self.ctrl_be.shutdown()
self.release()
self.owner.handle_close()
return True
def _acquire_admin_access(self):
if not self._validate_remote_admin_settings():
self.admin_access_status = "Remote management settings are invalid"
return
while True:
try:
mforms.App.get().set_status_text(
"Acquiring management access to target host...")
self.ctrl_be.acquire_admin_access()
mforms.App.get().set_status_text(
"Management support for target host enabled successfully.")
return True
except OperationCancelledError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nSSH connection was cancelled"
mforms.App.get().set_status_text(
"Cancelled SSH connection (%s)" % exc)
return None
except InvalidPasswordError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nCould not acquire management access to the server\n\n%s" % exc
if Utilities.show_error(
"Could not acquire management access for administration",
"%s" % exc, "Retry", "Cancel", "") == mforms.ResultOk:
continue
mforms.App.get().set_status_text("Could not Open WB Admin")
return None
def handle_on_close(self):
log_debug("Closing admin\n")
if self._timeout_tm:
Utilities.cancel_timeout(self._timeout_tm)
self._timeout_tm = None
nc.remove_observer(self.handle_server_state_changed)
App.get().set_status_text("Closing Administator.")
self.shutdown()
if not self.closing:
log_debug("Admin close cancelled\n")
return False
self.ctrl_be.shutdown()
self.release()
self.owner.handle_close()
return True
def get_db_connection(server_instance_settings):
if server_instance_settings.connection:
db_connection = MySQLConnection(server_instance_settings.connection)
ignore_error = False
error_location = None
the_error = None
try:
db_connection.connect()
except MySQLError, exc:
# errors that probably just mean the server is down can be ignored (ex 2013)
# errors from incorrect connect parameters should raise an exception
# ex 1045: bad password
if exc.code in (1045,):
raise exc
elif exc.code in (2013,):
ignore_error = True
error_location = exc.location
the_error = str(exc)
if not ignore_error:
if Utilities.show_warning("Could not connect to MySQL Server at %s" % error_location,
"%s\nYou can continue but some functionality may be unavailable." % the_error,
"Continue Anyway", "Cancel", "") != mforms.ResultOk:
raise MySQLError("", 0, "")
return db_connection
def openDocLib():
global docLibTab
global server_port
app = App.get()
# if docs datafiles are not installed, just open the docs home page
datafile = os.path.join(app.get_resource_path(""),
"modules/data/DocLibrary/mysqldoclib.sqlite")
if not os.path.exists(datafile):
Utilities.open_url("http://dev.mysql.com/doc/")
return 1
if docLibTab:
if docLibTab is True: # this will be True if an external browser is used
Utilities.open_url("http://localhost:%i" % server_port)
return 1
app.select_view(docLibTab)
return 1
try:
import mysqldoclib
except ImportError:
Utilities.show_error(
"Cannot Open Documentation Library",
'''pysqlite2 is not installed, please install python-sqlite2 or pysqlite2 to be able to use this feature.
Try running "easy_install pysqlite" with superuser privileges in the command line shell or, if using
Ubuntu, enable the Universe repository and install the python-pysqlite2 package from there.''',
"OK", "", "")
return 0
if server_port is None:
ready_event = Event()
#datadir = "./modules/data/DocLibrary/"
datadir = os.path.join(app.get_resource_path(""),
"modules/data/DocLibrary")
thread.start_new_thread(run_server, (datadir, ready_event))
# wait up to 1s for the doclib server to start
ready_event.wait(1)
if platform.system() == "Linux":
docLibTab = True
Utilities.open_url("http://localhost:%i" % server_port)
return 1
docLibTab = DocLibTab(server_port)
docLibTab.set_identifier("wb.doclib")
app.dock_view(docLibTab, "maintab")
app.set_view_title(docLibTab, "Doc Library (loading)")
app.set_status_text("Opening Doc Library...")
return 1
def run(self):
self._updating = False
self._invalid_text = False
self.form = Form(None, mforms.FormResizable)
self.form.set_title(self.title)
self.flist = newTreeView(mforms.TreeFlatList)
self.curdir = newTextEntry()
self.flist.add_column(mforms.IconStringColumnType, "File", 400, False)
self.flist.end_columns()
self.curdir.add_changed_callback(self.text_changed)
self.curdir.add_action_callback(self.text_action)
self.flist.add_activated_callback(self.on_cd)
self.flist.add_changed_callback(self.on_change)
accept = newButton()
accept.set_text("OK")
cancel = newButton()
cancel.set_text("Cancel")
button_box = newBox(True)
button_box.set_padding(10)
button_box.set_spacing(8)
Utilities.add_end_ok_cancel_buttons(button_box, accept, cancel)
box = newBox(False) # Hosts all entries on that dialog.
box.set_padding(10)
box.set_spacing(10)
box.add(self.curdir, False, False)
box.add(self.flist, True, True)
box.add(button_box, False, False)
self.form.set_content(box)
self.form.set_size(500, 400)
cancel.add_clicked_callback(self.cancel_action)
accept.add_clicked_callback(self.accept_action)
self.form.relayout()
self.form.center()
self.on_cd(0, 0)
# Don't use the accept button in run_modal or you won't be able to press <enter>
# to change the path via the top edit control.
self.form.run_modal(None, cancel)
def pack_to_top(self):
self.suspend_layout()
self.main_view.ui_profile.apply_style(self, 'page')
#if self.server_profile.admin_enabled:
self.file_name_ctrl = newTextEntry()
sys_config_path = self.server_profile.config_file_path
if sys_config_path is None:
sys_config_path = ""
self.file_name_ctrl.set_value(sys_config_path)
self.file_name_ctrl.set_size(300, -1)
self.file_name_ctrl.set_read_only(True)
self.section_ctrl = newSelector()
self.section_ctrl.set_size(150, -1)
#spacer = newPanel(mforms.TransparentPanel)
#spacer.set_size(100, 10)
self.bottom_box = newBox(True)
accept_btn = newButton()
accept_btn.set_text("Apply ...")
discard_btn = newButton()
discard_btn.set_text("Discard")
#self.add(self.search_panel, False, True)
self.add(self.tab_view, True, True)
self.add(self.bottom_box, False, False)
self.bottom_box.add(newLabel("Configuration File:"), False, True)
self.bottom_box.add(self.file_name_ctrl, True, True)
self.bottom_box.add(self.section_ctrl, False, True)
Utilities.add_end_ok_cancel_buttons(self.bottom_box, accept_btn,
discard_btn)
self.bottom_box.set_spacing(8)
self.bottom_box.set_padding(12)
accept_btn.add_clicked_callback(self.config_apply_changes_clicked)
discard_btn.add_clicked_callback(self.config_discard_changes_clicked)
self.resume_layout()
def _acquire_admin_access(self):
if not self._validate_remote_admin_settings():
self.admin_access_status = "Remote management settings are invalid"
return
while True:
try:
mforms.App.get().set_status_text("Acquiring management access to target host...")
self.ctrl_be.acquire_admin_access()
mforms.App.get().set_status_text("Management support for target host enabled successfully.")
return True
except wb_admin_ssh.ConnectionError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nSSH connection could not be established\n\n%s" % str(exc)
Utilities.show_error("Error opening SSH connection to server (%s@%s)" % (self.instance_profile.loginInfo["ssh.userName"], self.instance_profile.loginInfo["ssh.hostName"]), str(exc), "OK", "", "")
return None
except OperationCancelledError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nSSH connection was cancelled"
mforms.App.get().set_status_text("Cancelled SSH connection (%s)"%exc)
return None
def async_start_finished(self, status):
if status == "success":
self.print_output("Server start done.")
elif status == "bad_password":
r = Utilities.show_error("Start Server",
"A permission error occurred while attempting to start the server.\n"
"Administrator password was possibly wrong.",
"Retry", "Cancel", "")
if r == mforms.ResultOk:
pass
else:
self.print_output("Could not stop server. Permission denied")
else:
self.print_output("Could not start server: %s" % (status or "unknown error"))
Utilities.show_error("Could not start server", str(status), "OK", "", "")
self.refresh()
self.refresh_button.set_enabled(True)
self.start_stop_btn.set_enabled(True)
def pack_to_top(self):
self.suspend_layout()
self.main_view.ui_profile.apply_style(self, 'page')
#if self.server_profile.admin_enabled:
self.file_name_ctrl = newTextEntry()
sys_config_path = self.server_profile.config_file_path
if sys_config_path is None:
sys_config_path = ""
self.file_name_ctrl.set_value(sys_config_path)
self.file_name_ctrl.set_size(300, -1)
self.file_name_ctrl.set_read_only(True)
self.section_ctrl = newSelector()
self.section_ctrl.set_size(150, -1)
#spacer = newPanel(mforms.TransparentPanel)
#spacer.set_size(100, 10)
self.bottom_box = newBox(True)
accept_btn = newButton()
accept_btn.set_text("Apply ...")
discard_btn = newButton()
discard_btn.set_text("Discard")
#self.add(self.search_panel, False, True)
self.add(self.tab_view, True, True)
self.add(self.bottom_box, False, False)
self.bottom_box.add(newLabel("Configuration File:"), False, True)
self.bottom_box.add(self.file_name_ctrl, True, True)
self.bottom_box.add(self.section_ctrl, False, True)
Utilities.add_end_ok_cancel_buttons(self.bottom_box, accept_btn, discard_btn)
self.bottom_box.set_spacing(8)
self.bottom_box.set_padding(12)
accept_btn.add_clicked_callback(self.config_apply_changes_clicked)
discard_btn.add_clicked_callback(self.config_discard_changes_clicked)
self.resume_layout()
def validate(self):
error = ""
if self._dest_directory.get_string_value() == "":
error = "The backup directory must be specified."
elif self._name.get_string_value().strip() == "":
error = "A label to identify the profile must be set."
if self.label_validation is not None:
if not self.label_validation(self._name.get_string_value(), self._profile):
error = "A unique label to identify the profile must be set."
# compress doesn't work with apply-log
if not error and self._compress_backup.get_active() and self._apply_log.get_active():
error = "Compress cannot be used with the backup-and-apply-log option, please unselect either one."
if error != "":
Utilities.show_error("Save Backup Profile", error, "OK", "", "")
return False
else:
return True
def revoke_all(self):
if self._selected_user:
if Utilities.show_message(
"Revoke All Privileges",
"Please confirm revokation of all privileges for the account '%s'@'%s'.\nNote: the account itself will be maintained."
% (self._selected_user.username, self._selected_user.host),
"Revoke", "Cancel", "") == mforms.ResultOk:
self._selected_user.revoke_all()
self._selected_user.load(self._selected_user.username,
self._selected_user.host)
self.show_user(self._selected_user)
def __init__(self, ctrl_be, server_profile, main_view, editor):
mforms.AppView.__init__(self, False, "administrator", False)
self.editor = editor
self.owner = main_view
self.tabs = []
self.name2page = {}
self.config_ui = None
self.closing = False
self.tabview = newTabView(True)
self.ctrl_be = ctrl_be
self.old_active_tab = None
self.server_profile = server_profile
self.refresh_tasks_sleep_time = 2
# if we're in the Mac, we need to set the background color of the main view of the tab to white,
# so that MTabSwitcher will take the cue and set the tab color to white too
if self.server_profile.host_os == wbaOS.darwin:
self.set_back_color("#ffffff")
# Setup self
self.set_managed()
self.set_release_on_add()
self.on_close(wb_admin_utils.weakcb(self, "handle_on_close"))
self.ctrl_be.add_me_for_event("server_started", self)
self.ctrl_be.add_me_for_event("server_stopped", self)
self.add(self.tabview, True, True)
Utilities.add_timeout(0.5, weakcb(self, "timeout"))
self.timeout_thread = threading.Thread(target = self.refresh_tasks_thread)
self.timeout_thread.setDaemon(True)
self.timeout_thread.start()
self.tabview.add_tab_changed_callback(self.tab_changed)
self.timeout() # will call self.connect_mysql() and check if mysql is running
self.ctrl_be.continue_events() # Process events which are queue during init
dprint_ex(1, "WBA init complete")
def start_stop_clicked(self):
self.start_error_log_tracking()
status = self.ctrl_be.is_server_running(verbose=1)
# Check if server was started/stoped from outside
if self.is_server_running_prev_check == status:
if status == "running":
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
try:
if self.server_control and not self.server_control.stop_async(
self.async_stop_callback):
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error(
"Stop Server",
"An error occurred while attempting to stop the server.%s %s\n"
% (type(exc).__name__, exc), "OK", "", "")
return
elif status == "stopped":
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
try:
if self.server_control and not self.server_control.start_async(
self.async_start_callback):
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error(
"Stop Server",
"An error occurred while attempting to stop the server.%s %s\n"
% (type(exc).__name__, exc), "OK", "", "")
return
def async_start_finished(self, status):
if status == "success":
self.print_output("Server start done.")
elif status == "bad_password":
r = Utilities.show_error(
"Start Server",
"A permission error occurred while attempting to start the server.\n"
"Administrator password was possibly wrong.", "Retry",
"Cancel", "")
if r == mforms.ResultOk:
pass
else:
self.print_output("Could not stop server. Permission denied")
else:
self.print_output("Could not start server: %s" %
(status or "unknown error"))
Utilities.show_error("Could not start server", str(status), "OK",
"", "")
self.refresh()
self.refresh_button.set_enabled(True)
self.start_stop_btn.set_enabled(True)
def async_stop_finished(self, status): # status can be one of success, bad_password or error message
if status == "success":
self.print_output("Server stop done.")
elif status == "bad_password":
r = Utilities.show_error("Stop Server",
"A permission error occurred while attempting to stop the server.\n"
"Administrator password was possibly wrong.",
"Retry", "Cancel", "")
if r == mforms.ResultOk:
if self.server_control.stop_async(self.async_stop_callback):
return
else:
self.print_output("Could not stop server. Permission denied")
elif status == "need_password":
if self.server_control.stop_async(self.async_stop_callback, False):
return
else:
self.print_output("Could not stop server: %s" % (status or "unknown error"))
Utilities.show_error("Could not stop server", str(status), "OK", "", "")
self.refresh()
self.refresh_button.set_enabled(True)
self.start_stop_btn.set_enabled(True)
self.print_new_error_log_entries()
def start_stop_clicked(self):
self.start_error_log_tracking()
status = self.ctrl_be.is_server_running(verbose=1)
# Check if server was started/stoped from outside
if self.is_server_running_prev_check == status:
if status == "running":
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
try:
if self.server_control and not self.server_control.stop_async(self.async_stop_callback):
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error("Stop Server",
"An error occurred while attempting to stop the server.%s %s\n" % (type(exc).__name__, exc),
"OK", "", "")
return
elif status == "stopped":
self.start_stop_btn.set_enabled(False)
self.refresh_button.set_enabled(False)
try:
if self.server_control and not self.server_control.start_async(self.async_start_callback):
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
return
except Exception, exc:
self.start_stop_btn.set_enabled(True)
self.refresh_button.set_enabled(True)
Utilities.show_error("Stop Server",
"An error occurred while attempting to stop the server.%s %s\n" % (type(exc).__name__, exc),
"OK", "", "")
return
def del_account(self):
if self._selected_user:
if not self._selected_user.is_commited or Utilities.show_message(
"Remove Account",
"The account '%s' will be permanently removed. Please confirm."
% (self._selected_user.formatted_name()), "Remove",
"Cancel", "") == mforms.ResultOk:
the_name = self._selected_user.formatted_name()
self.owner.secman.delete_account(self._selected_user)
self._selected_user = None
self._selected_user_original = None
self.refresh()
self.user_selected()
mforms.App.get().set_status_text("Account '%s' was deleted" %
the_name)
def __init__(self, ctrl_be, server_profile, main_view, editor):
mforms.AppView.__init__(self, False, "Administrator", "Administrator",
False)
self.editor = editor
self.owner = main_view
self.tabs = []
self.name2page = {}
self.config_ui = None
self.closing = False
self.tabview = newTabView(True)
self.ctrl_be = ctrl_be
self.old_active_tab = None
self.server_profile = server_profile
if self.server_profile.host_os == wbaOS.darwin:
self.set_back_color(
Color.getSystemColor(ControlBackgroundColor).to_html())
# Setup self
self.set_managed()
self.set_release_on_add()
self.on_close(wb_admin_utils.weakcb(self, "handle_on_close"))
nc.add_observer(self.handle_server_state_changed,
"GRNServerStateChanged", editor)
nc.add_observer(self.updateColors, "GNColorsChanged")
self.ctrl_be.add_me_for_event("server_started", self)
self.ctrl_be.add_me_for_event("server_stopped", self)
self.add(self.tabview, True, True)
self._timeout_tm = Utilities.add_timeout(0.5, weakcb(self, "timeout"))
self.tabview.add_tab_changed_callback(self.tab_changed)
self.timeout()
# check initial state
if editor.isConnected == 1:
self.ctrl_be.event_from_main("server_started")
elif editor.isConnected == -1:
self.ctrl_be.event_from_main("server_offline")
self.ctrl_be.continue_events(
) # Process events which are queue during init
log_debug("WBA init complete\n")
def __init__(self, ctrl_be, server_profile, main_view, editor):
mforms.AppView.__init__(self, False, "administrator", False)
self.editor = editor
self.owner = main_view
self.tabs = []
self.name2page = {}
self.config_ui = None
self.closing = False
self.tabview = newTabView(True)
self.ctrl_be = ctrl_be
self.old_active_tab = None
self.server_profile = server_profile
# if we're in the Mac, we need to set the background color of the main view of the tab to white,
# so that MTabSwitcher will take the cue and set the tab color to white too
if self.server_profile.host_os == wbaOS.darwin:
self.set_back_color("#ffffff")
# Setup self
self.set_managed()
self.set_release_on_add()
self.on_close(wb_admin_utils.weakcb(self, "handle_on_close"))
nc.add_observer(self.handle_server_state_changed, "GRNServerStateChanged", editor)
self.ctrl_be.add_me_for_event("server_started", self)
self.ctrl_be.add_me_for_event("server_stopped", self)
self.add(self.tabview, True, True)
self._timeout_tm = Utilities.add_timeout(0.5, weakcb(self, "timeout"))
self.tabview.add_tab_changed_callback(self.tab_changed)
self.timeout()
# check initial state
if editor.isConnected == 1:
self.ctrl_be.event_from_main("server_started")
elif editor.isConnected == -1:
self.ctrl_be.event_from_main("server_offline")
self.ctrl_be.continue_events() # Process events which are queue during init
log_debug("WBA init complete\n")
def openDocLib():
global docLibTab
global server_port
if docLibTab:
if docLibTab is True: # this will be True if an external browser is used
Utilities.open_url("http://localhost:%i"%server_port)
return 1
App.get().select_view("wb.doclib")
return 1
app = App.get()
try:
import mysqldoclib
except ImportError:
Utilities.show_error("Cannot Open Documentation Library",
'''pysqlite2 is not installed, please install python-sqlite2 or pysqlite2 to be able to use this feature.
Try running "easy_install pysqlite" with superuser privileges in the command line shell or, if using
Ubuntu, enable the Universe repository and install the python-pysqlite2 package from there.''',
"OK", "", "")
return 0
if server_port is None:
ready_event = Event()
#datadir = "./modules/data/DocLibrary/"
datadir = os.path.join(app.get_resource_path(""), "modules/data/DocLibrary")
thread.start_new_thread(run_server, (datadir, ready_event))
# wait up to 1s for the doclib server to start
ready_event.wait(1)
if platform.system() == "Linux":
docLibTab = True
Utilities.open_url("http://localhost:%i"%server_port)
return 1
docLibTab = DocLibTab(server_port)
docLibTab.set_identifier("wb.doclib")
app.dock_view(docLibTab, "maintab")
app.set_view_title(docLibTab, "Doc Library (loading)")
app.set_status_text("Opening Doc Library...")
return 1
def __init__(self, server_profile, ctrl_be, monitor):
mforms.Box.__init__(self, True) # True - vertical layout
self.tasks_side = newTaskSidebar()
self.content_box = newBox(False)
self.tasks_side.set_selection_color(mforms.SystemHighlight)
self.tabs = []
self.name2page = {}
self.config_ui = None
self.closing = False
self.tabview = newTabView(True)
self.ctrl_be = ctrl_be
self.old_active_tab = None
self.server_profile = server_profile
self.refresh_tasks_sleep_time = 2
self.ui_profile = UIProfile(server_profile)
# Setup self
self.set_managed()
self.ui_profile.apply_style(self, "main")
if server_profile.host_os == wbaOS.windows:
side_panel = newPanel(mforms.StyledHeaderPanel)
side_panel.set_title(" Task and Object Browser")
side_panel.add(self.tasks_side)
self.add(side_panel, False, True)
self.content_panel = newPanel(mforms.StyledHeaderPanel)
self.content_panel.set_title(" Task and Object Browser")
self.content_panel.add(self.content_box)
self.add(self.content_panel, True, True)
else:
vbox = newBox(False)
vbox.add(self.tasks_side, True, True)
self.add(vbox, False, False)
vbox = newBox(False)
self.content_label = newHeaderLabel("")
self.ui_profile.apply_style(self.content_label, 'content-label')
vbox.add(self.content_label, False, False)
vbox.add(self.content_box, True, True)
self.add(vbox, True, True)
self.ctrl_be.add_me_for_event("server_started", self)
self.ctrl_be.add_me_for_event("server_stopped", self)
# Setup tasks sidebar
self.fill_task_sidebar()
self.tasks_side.add_on_section_command_callback(self.section_clicked)
self.tasks_side.show()
self.tasks_side.set_size(220, -1)
# Setup content box
self.content_box.add(self.tabview, True, True)
# Create content pages
self.server_status_page = ServerStatusPage(server_profile, ctrl_be, self)
self.config_ui = WbAdminConfigFileUI(server_profile = server_profile, ctrl_be = ctrl_be, main_view = self)
self.startup = WbAdminConfigurationStartup(ctrl_be, server_profile, self)
self.security = WbAdminSecurity(self.ctrl_be, server_profile, self)
self.variables = WbAdminVariables(self.ctrl_be, server_profile, self)
self.logs = WbAdminLogs(self.ctrl_be, server_profile, self)
self.dump = WbAdminExport(server_profile, self.ctrl_be, self)
Utilities.add_timeout(0.5, weakcb(self, "timeout"))
self.timeout_thread = threading.Thread(target = self.refresh_tasks_thread)
self.timeout_thread.setDaemon(True)
self.timeout_thread.start()
self.tabview.add_tab_changed_callback(self.tab_changed)
self.timeout() # will call self.connect_mysql() and check if mysql is running
self.ctrl_be.continue_events() # Process events which are queue during init
dprint_ex(1, "WBA init complete")
self.tasks_side.select_entry("MANAGEMENT", "Server Status")
self.server_status_page.page_activated()
def get_string_value_from_control(self, ctrl):
#ctrl is a tupple from map
value = ""
tag = ctrl[0]
def control(idx):
return ctrl[1][idx]
is_multiple = False
control_name = control(1).get_name()
if control_name == "Multiple":
is_multiple = True
if tag == "txt":
value = (control(1).get_string_value(),)
elif tag == "spn":
# (enabled, te, unitcontrol, unit_items)). Note! unitcontrol and unit_items may be None
value = control(1).get_string_value().strip(" \r\n\t")
if control(2) is not None:
value += control(2).get_string_value()
elif tag == "drp":
value = control(1).get_string_value()
elif tag == "dir":
value = control(1).get_string_value()
if is_multiple:
value = value.split(';')
elif tag == "chk":
value = (control(0).get_active(),)
# Here we detect if value has signs of multi line option.
# For example, user entered separator char.
# It is enough to ensure that the first item in tuple is string
is_string = False # We only can detect multi-line in strings (rework is scheduled for 5.3)
has_separator = False
if type(value) is tuple:
value_len = len(value)
if value_len == 1: # Check only single item tuples
is_string = type(value[0]) is str or type(value[0]) is unicode
if is_string:
has_separator = value[0].find(multi_separator) > 0
else:
is_string = type(value) is str or type(value) is unicode
has_separator = value.find(multi_separator) > 0
if is_multiple == False and is_string and has_separator and not self.loading:
answer = Utilities.show_message("Confirm"
,"Multi-line option format entered. Would you like to convert option to multi-line?"
, "Convert", "Skip", "")
if answer == mforms.ResultOk:
control(1).set_name("Multiple")
# some controls return values in form of one-item tuples
# so we need to extract that item for processing below
if has_separator and is_string:
if type(value) is tuple:
if len(value) == 1: # Only extract values from one-item tuples
value = value[0] # If tuple has more items it already has been converted to multi-line
# skip multi line values - no need to convert. Also skip non-string option values
if type(value) is not tuple:
value = map(lambda x: x.strip(multi_separator), value.split(multi_separator))
if type(value) is not list and type(value) is not tuple:
value = (value,)
return value
def openDocLib():
Utilities.open_url("http://dev.mysql.com/doc/refman/5.7/en/index.html")
return 1
try:
adminTab = AdministratorTab(server_instance)
except wb_admin_ssh.ConnectionError, exc:
Utilities.show_error(
"Error Connecting to Server (%s@%s)"
% (server_instance.loginInfo["ssh.userName"], server_instance.loginInfo["ssh.hostName"]),
str(exc),
"OK",
"",
"",
)
app.set_status_text("Could not Open WB Admin")
return None
except MySQLError, exc:
if exc.message:
Utilities.show_error("Error Connecting to MySQL Server (%s)" % exc.location, str(exc), "OK", "", "")
app.set_status_text("Could not Open WB Admin")
return None
except OperationCancelledError, exc:
app.set_status_text("Cancelled (%s)" % exc)
return None
except Exception, exc:
import traceback
traceback.print_exc()
Utilities.show_error(
"Error Starting Workbench Administrator", "%s: %s" % (type(exc).__name__, exc), "OK", "", ""
)
app.set_status_text("Could not Open WB Admin")
return None
def copy_to_clipboard(self): Utilities.set_clipboard_text(self.startup_msgs_log.get_string_value())
def shutdown(self):
if self._refresh_timeout:
Utilities.cancel_timeout(self._refresh_timeout)
self._refresh_timeout = None
except OperationCancelledError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nSSH connection was cancelled"
mforms.App.get().set_status_text("Cancelled SSH connection (%s)"%exc)
return None
except InvalidPasswordError, exc:
self.admin_access_status = "Remote management capabilities are currently unavailable.\nCould not acquire management access to the server\n\n%s" % exc
if Utilities.show_error("Could not acquire management access for administration", "%s" % exc, "Retry", "Cancel", "") == mforms.ResultOk:
continue
mforms.App.get().set_status_text("Could not Open WB Admin")
return None
except Exception, exc:
import traceback
traceback.print_exc()
self.admin_access_status = "Remote management capabilities are currently unavailable.\nCould not acquire management access to the server\n\n%s" % exc
mforms.App.get().set_status_text("Could not Open WB Admin")
if Utilities.show_error("Could not acquire management access for administration", "%s: %s" % (type(exc).__name__, exc), "Settings...", "Cancel", "") == mforms.ResultOk:
grt.modules.Workbench.showInstanceManagerFor(self.connection)
return None
def acquire_admin_access(self, ignore_failure=False):
if not self._acquire_admin_access():
if ignore_failure:
return True
if not self.error_box:
self.error_box = mforms.newBox(True)
self.error_box.set_padding(50)
error_label = mforms.newLabel(self.admin_access_status)
error_label.set_style(mforms.BigBoldStyle)
self.error_box.add(error_label, False, True)
self.admin_tab.add_page(self.error_box)
else:
# ex 1045: bad password
if exc.code in (1045,):
raise exc
elif exc.code in (2013,):
ignore_error = True
error_location = exc.location
the_error = str(exc)
if not ignore_error:
if Utilities.show_warning("Could not connect to MySQL Server at %s" % error_location,
"%s\nYou can continue but some functionality may be unavailable." % the_error,
"Continue Anyway", "Cancel", "") != mforms.ResultOk:
raise MySQLError("", 0, "")
return db_connection
else:
Utilities.show_warning("WB Admin", "Server instance has no database connection specified.\nSome functionality will not be available.", "OK", "", "")
return None
def weakcb(object, cbname):
"""Create a callback that holds a weak reference to the object. When passing a callback
for mforms, use this to create a ref to it and prevent circular references that are never freed.
"""
def call(ref, cbname):
callback = getattr(ref(), cbname, None)
if callback is None:
print "Object has no callback %s"%cbname
