def _flush_messages(self):
while len(self._log_queue) > 0:
mtype, text, detail = self._log_queue.popleft()
if "\n" in detail:
detail = "\n "+("\n ".join(detail.split("\n")))
if mtype == "INFO":
if detail:
self._log_text.append_text_and_scroll("%s: %s\n" % (text, detail), True)
else:
self._log_text.append_text_and_scroll("%s\n" % (text), True)
elif mtype == "OUTPUT":
# output text must already come with newlines
if detail:
self._log_text.append_text_and_scroll("%s: %s" % (text, detail), True)
else:
self._log_text.append_text_and_scroll("%s" % (text), True)
elif mtype == "PROGRESS":
pct, y, text = text.partition(":")
try:
self.update_progress(locale.atof(pct), text)
except Exception:
grt.log_debug('Wizard', 'Exception raised when converting "%s" to float using locale.atof(). Exception ignored\n' % pct)
else:
if mtype == "ERROR":
self._errors += 1
self._task_errors.append(text)
elif mtype == "WARNING":
self._warnings += 1
self._task_warnings.append(text)
if detail:
self._log_text.append_text_and_scroll("%s: %s: %s\n" % (mtype, text, detail), True)
else:
self._log_text.append_text_and_scroll("%s: %s\n" % (mtype, text), True)
def reader(self, ssh_session):
what = None
out = ""
timeouts = 12
while self.running[0]: # running is passed in list via "refernce"
try:
ch = ssh_session.recv(1)
timeouts = 12
if ch == "C":
what = self.parse_cpu
elif ch == "\r" or ch == "\n":
if what is not None:
what(out)
what = None
out = ""
elif ch in "0123456789. ":
out += ch
elif ch == ",":
out += "."
else:
what = None
out = ""
except socket.timeout:
timeouts -= 1
if timeouts <= 0:
ssh_session.close()
raise Exception("Can't read from remote Windows script")
log_debug('%s:%s.reader()' % (_this_file, self.__class__.__name__),
'Leaving monitor thread which polls remote windows\n')
def poll_sources(self):
while self.running[0] and self.ctrl_be.running:
#sleep here
for cmd in self.sources:
cmd.poll()
time.sleep(self.interval)
log_debug('%s:%s.poll_sources()' % (_this_file, self.__class__.__name__), 'Exiting monitor thread...\n')
def _flush_messages(self):
while len(self._log_queue) > 0:
mtype, text, detail = self._log_queue.popleft()
if "\n" in detail:
detail = "\n "+("\n ".join(detail.split("\n")))
if mtype == "INFO":
if detail:
self._log_text.append_text_and_scroll("%s: %s\n" % (text, detail), True)
else:
self._log_text.append_text_and_scroll("%s\n" % (text), True)
elif mtype == "OUTPUT":
# output text must already come with newlines
if detail:
self._log_text.append_text_and_scroll("%s: %s" % (text, detail), True)
else:
self._log_text.append_text_and_scroll("%s" % (text), True)
elif mtype == "PROGRESS":
pct, y, text = text.partition(":")
try:
self.update_progress(locale.atof(pct), text)
except Exception:
grt.log_debug('Wizard', 'Exception raised when converting "%s" to float using locale.atof(). Exception ignored\n' % pct)
else:
if mtype == "ERROR":
self._errors += 1
self._task_errors.append(text)
elif mtype == "WARNING":
self._warnings += 1
self._task_warnings.append(text)
if detail:
self._log_text.append_text_and_scroll("%s: %s: %s\n" % (mtype, text, detail), True)
else:
self._log_text.append_text_and_scroll("%s: %s\n" % (mtype, text), True)
def wait_connection(self, port):
tunnel = self.tunnel_by_port.get(port)
if not tunnel:
return 'Could not find a tunnel for port %d' % port
error = None
if tunnel.isAlive():
while True:
# Process any message in queue. Every retrieved message is printed.
# If an error is detected in the queue, exit returning its message:
try:
msg_type, msg = tunnel.q.get_nowait()
except Queue.Empty:
pass
else:
_msg = msg
if type(msg) is tuple:
msg = '\n' + ''.join(traceback.format_exception(*msg))
_msg = str(_msg[1])
log_debug(_this_file, "%s: %s\n" % (msg_type, msg))
if msg_type == 'ERROR':
error = _msg
break # Exit returning the error message
if not tunnel.is_connecting() or not tunnel.isAlive():
break
time.sleep(0.3)
log_debug(_this_file, "returning from wait_connection(%s): %s\n" % (port, error))
return error
def save_file_content_and_backup(self, path, content, backup_extension, as_admin = False, admin_password = None):
# Check if dir, where config file will be stored is writable
dirname, filename = splitpath(path)
if not as_admin and not self.is_dir_writable(dirname.strip(" \r\t\n")):
raise PermissionDeniedError("Cannot write to directory %s" % dirname)
if self.ssh is not None:
## Get temp dir for using as tmpdir
tmpdir, status = self.process_ops.get_cmd_output("echo %temp%")
if type(tmpdir) is unicode:
tmpdir = tmpdir.encode("utf8")
if type(tmpdir) is str:
tmpdir = tmpdir.strip(" \r\t\n")
if tmpdir[1] == ":":
tmpdir = tmpdir[2:]
else:
log_debug(_this_file, '%s: Temp directory path "%s" is not in expected form. The expected form is something like "C:\\Windows\\Temp"\n' % (self.__class__.__name__, tmpdir) )
tmpdir = None
log_debug2(_this_file, '%s: Got temp dir: "%s"\n' % (self.__class__.__name__, tmpdir) )
else:
tmpdir = None
if not tmpdir:
tmpdir = dirname
tmpfilename = tmpdir + r"\workbench-temp-file.ini"
log_debug(_this_file, '%s: Remotely writing contents to temporary file "%s"\n' % (self.__class__.__name__, tmpfilename) )
log_debug3(_this_file, '%s: %s\n' % (self.__class__.__name__, content) )
self.ssh.set_contents(tmpfilename, content)
if backup_extension:
log_debug(_this_file, '%s: Backing up "%s"\n' % (self.__class__.__name__, path) )
backup_cmd = "copy /y " + quote_path_win(path) + " " + quote_path_win(path+backup_extension)
msg, code = self.process_ops.get_cmd_output(backup_cmd)
if code != 0:
print backup_cmd, "->", msg
log_error(_this_file, '%s: Error backing up file: %s\n' % (self.__class__.__name__, backup_cmd+'->'+msg) )
raise RuntimeError("Error backing up file: %s" % msg)
copy_to_dest = "copy /y " + quote_path_win(tmpfilename) + " " + quote_path_win(path)
delete_tmp = "del " + quote_path_win(tmpfilename)
log_debug(_this_file, '%s: Copying file to final destination: "%s"\n' % (self.__class__.__name__, copy_to_dest) )
msg, code = self.process_ops.get_cmd_output(copy_to_dest)
if code != 0:
print copy_to_dest, "->", msg
log_error(_this_file, '%s: Error copying temporary file over destination file: %s\n%s to %s\n' % (self.__class__.__name__, msg, tmpfilename, path) )
raise RuntimeError("Error copying temporary file over destination file: %s\n%s to %s" % (msg, tmpfilename, path))
log_debug(_this_file, '%s: Deleting tmp file: "%s"\n' % (self.__class__.__name__, delete_tmp) )
msg, code = self.process_ops.get_cmd_output(delete_tmp)
if code != 0:
print "Could not delete temporary file %s: %s" % (tmpfilename, msg)
log_info(_this_file, '%s: Could not delete temporary file "%s": %s\n' % (self.__class__.__name__, tmpfilename, msg) )
else:
raise Exception("No SSH session active, cannot save file remotely")
def fetch_windows_shell_info(self):
# get some info from the remote shell
result, code = self.get_cmd_output("chcp.com")
if code == 0:
result = result.strip(" .\r\n").split()
if len(result) > 0:
self.cmd_output_encoding = "cp" + result[-1]
else:
print "WARNING: Unable to determine codepage from shell: %s" % result
log_warning(_this_file, '%s.fetch_windows_shell_info(): WARNING: Unable to determine codepage from shell: "%s"\n' % (self.__class__.__name__, str(result)) )
result, code = self.get_cmd_output("echo %PROCESSOR_ARCHITECTURE%")
if result:
result = result.strip()
ProgramFilesVar = None
x86var = None
if result != "x86":#we are on x64 win in x64 mode
x86var = WIN_PROGRAM_FILES_X86_VAR
ProgramFilesVar = WIN_PROGRAM_FILES_VAR
else:
result, code = self.get_cmd_output("echo %PROCESSOR_ARCHITEW6432%")
if result:
result = result.strip()
if result == "%PROCESSOR_ARCHITEW6432%":#we are on win 32
x86var = WIN_PROGRAM_FILES_VAR
ProgramFilesVar = WIN_PROGRAM_FILES_VAR
else:#32bit app on x64 win
x86var = WIN_PROGRAM_FILES_VAR
ProgramFilesVar = WIN_PROGRAM_FILES_X64_VAR
result, code = self.get_cmd_output("echo "+ ProgramFilesVar)
if code == 0:
self.target_shell_variables["%ProgramFiles%"] = result.strip("\r\n")
if ProgramFilesVar != "%ProgramFiles%":
self.target_shell_variables[ProgramFilesVar] = result.strip("\r\n")
else:
print "WARNING: Unable to fetch ProgramFiles value in Windows machine: %s"%result
log_warning(_this_file, '%s.fetch_windows_shell_info(): WARNING: Unable to fetch ProgramFiles value in Windows machine: "%s"\n' % (self.__class__.__name__, str(result)) )
# this one only exists in 64bit windows
result, code = self.get_cmd_output("echo "+ x86var)
if code == 0:
self.target_shell_variables["%ProgramFiles(x86)%"] = result.strip("\r\n")
else:
print "WARNING: Unable to fetch ProgramFiles(x86) value in local Windows machine: %s"%result
log_warning(_this_file, '%s.fetch_windows_shell_info(): WARNING: Unable to fetch ProgramFiles(x86) value in local Windows machine: "%s"\n' % (self.__class__.__name__, str(result)) )
log_debug(_this_file, '%s.fetch_windows_shell_info(): Encoding: "%s", Shell Variables: "%s"\n' % (self.__class__.__name__, self.cmd_output_encoding, str(self.target_shell_variables)))
def poll(self):
output = StringIO.StringIO()
if self.ctrl_be.server_helper.execute_command("/usr/bin/uptime", output_handler=output.write) == 0:
data = output.getvalue().strip(" \r\t\n,:.")
load_value = data.split()[-3]
# in some systems, the format is x.xx x.xx x.xx and in others, it's x.xx, x.xx, x.xx
load_value = load_value.rstrip(",")
try:
result = float(load_value.replace(',','.'))
except (ValueError, TypeError):
log_error(_this_file, "Shell source %s returned wrong value. Expected int or float but got %s\n" % (self.name, load_value))
result = 0
if self.widget is not None:
self.widget.set_value(self.calc_cb(result) if self.calc_cb else result)
if self.label_cb is not None:
self.ctrl_be.uitask(self.label.set_text, self.label_cb(result))
else:
log_debug(_this_file, "CPU stat command returned error: %s\n" % output.getvalue())
def reverseEngineer(cls, connection, catalog_name, schemata_list, context):
from grt.modules import MysqlSqlFacade
grt.send_progress(0, "Reverse engineering catalog information")
cls.check_interruption()
catalog = cls.reverseEngineerCatalog(connection, catalog_name)
# calculate total workload 1st
grt.send_progress(0.1, 'Preparing...')
get_tables = context.get("reverseEngineerTables", True)
# 10% of the progress is for preparation
total = 1e-10 # total should not be zero to avoid DivisionByZero exceptions
accumulated_progress = 0.1
total += len(cls.getTableNames(connection, catalog_name,
'')) if get_tables else 0
grt.send_progress(0.1, "Gathered stats")
# Now the second pass for reverse engineering tables:
if get_tables:
idx = 0
for object_type, name, tbl_name, _, sql in cls.execute_query(
connection, "SELECT * FROM sqlite_master"):
if type in ('view', 'trigger'
) or not sql or tbl_name.startswith('sqlite_'):
continue
sql = sql.replace('[', '').replace(']', '')
grt.log_debug('SQLiteReverseEngineering',
'Procesing this sql:\n%s;' % sql)
MysqlSqlFacade.parseSqlScriptString(catalog, sql)
cls.check_interruption()
grt.send_progress(0.1 + idx / total,
'Object %s reverse engineered!' % name)
idx += 1
grt.send_progress(1.0, 'Reverse engineering completed!')
return catalog
def testInstanceSettingByName(what, connection, server_instance):
global test_ssh_connection
log_debug(_this_file, "Test %s in %s\n" % (what, connection.name))
profile = ServerProfile(connection, server_instance)
if what == "connect_to_host":
if test_ssh_connection:
test_ssh_connection = None
log_info(_this_file, "Instance test: Connecting to %s\n" % profile.ssh_hostname)
try:
test_ssh_connection = wb_admin_control.WbAdminControl(profile, connect_sql=False)
test_ssh_connection.init()
grt.send_info("connected.")
except Exception, exc:
import traceback
traceback.print_exc()
return "ERROR "+str(exc)
except:
def reverseEngineer(cls, connection, catalog_name, schemata_list, context):
from grt.modules import MysqlSqlFacade
grt.send_progress(0, "Reverse engineering catalog information")
cls.check_interruption()
catalog = cls.reverseEngineerCatalog(connection, catalog_name)
# calculate total workload 1st
grt.send_progress(0.1, 'Preparing...')
get_tables = context.get("reverseEngineerTables", True)
# 10% of the progress is for preparation
total = 1e-10 # total should not be zero to avoid DivisionByZero exceptions
accumulated_progress = 0.1
total += len(cls.getTableNames(connection, catalog_name, '')) if get_tables else 0
grt.send_progress(0.1, "Gathered stats")
# Now the second pass for reverse engineering tables:
if get_tables:
idx = 0
for object_type, name, tbl_name, _, sql in cls.execute_query(connection, "SELECT * FROM sqlite_master"):
if type in ('view', 'trigger') or not sql or tbl_name.startswith('sqlite_'):
continue
sql = sql.replace('[', '').replace(']', '')
grt.log_debug('SQLiteReverseEngineering', 'Procesing this sql:\n%s;' % sql)
MysqlSqlFacade.parseSqlScriptString(catalog, sql)
cls.check_interruption()
grt.send_progress(0.1 + idx / total, 'Object %s reverse engineered!' % name)
idx += 1
grt.send_progress(1.0, 'Reverse engineering completed!')
return catalog
def save_file_content_and_backup(self, filename, content, backup_extension, as_admin = False, admin_password = None):
log_debug(_this_file, '%s: Saving file "%s" with backup (sudo="%s")\n' % (self.__class__.__name__, filename, as_admin) )
if as_admin:
# The delete argument is only available starting from py 2.6 (NamedTemporaryFile deletes files on close in all cases, unless you pass delete=False)
tmp = tempfile.NamedTemporaryFile(dir=self.tempdir)
tmp_name = tmp.name
try:
log_debug(_this_file, '%s: Writing file contents to tmp file "%s"\n' % (self.__class__.__name__, tmp_name) )
tmp.write(content)
tmp.flush()
if backup_extension and os.path.exists(filename):
log_debug(_this_file, '%s: Creating backup of "%s" to "%s"\n' % (self.__class__.__name__, filename, filename+backup_extension))
self._copy_file(source = filename, dest = filename + backup_extension,
as_admin = as_admin, admin_password = admin_password)
log_debug(_this_file, '%s: Copying over tmp file to final filename using sudo: %s -> %s\n' % (self.__class__.__name__, tmp_name, filename) )
self._copy_file(source = tmp_name, dest = filename, as_admin = as_admin, admin_password = admin_password)
log_debug(_this_file, '%s: Copying file done\n' % self.__class__.__name__)
tmp.close()
except Exception, exc:
log_error(_this_file, '%s: Exception caught: %s\n' % (self.__class__.__name__, str(exc)) )
if tmp:
tmp.close()
raise
def save_file_content_and_backup(self, path, content, backup_extension, as_admin = False, admin_password = None):
# Check if dir, where config file will be stored is writable
dirname, filename = splitpath(path)
if not as_admin and not self.is_dir_writable(dirname.strip(" \r\t\n")):
raise PermissionDeniedError("Cannot write to directory %s" % dirname)
if self.ssh is not None:
## Get home dir for using as tmpdir
homedir, status = self.process_ops.get_cmd_output("echo ~")
if type(homedir) is unicode:
homedir = homedir.encode("utf8")
if type(homedir) is str:
homedir = homedir.strip(" \r\t\n")
else:
homedir = None
log_debug2(_this_file, '%s: Got home dir: "%s"\n' % (self.__class__.__name__, homedir) )
if not homedir:
raise Exception("Unable to get path for remote home directory")
tmpfilename = homedir + "/.wba.temp"
log_debug(_this_file, '%s: Remotely writing contents to temporary file "%s"\n' % (self.__class__.__name__, tmpfilename) )
log_debug3(_this_file, '%s: %s\n' % (self.__class__.__name__, content) )
self.ssh.set_contents(tmpfilename, content)
if backup_extension:
log_debug(_this_file, '%s: Backing up %s\n' % (self.__class__.__name__, path) )
backup_cmd = "/bin/cp " + quote_path(path) + " " + quote_path(path+backup_extension)
self.process_ops.exec_cmd(backup_cmd, as_admin, admin_password)
copy_to_dest = "/bin/cp " + quote_path(tmpfilename) + " " + quote_path(path)
delete_tmp = "/bin/rm " + quote_path(tmpfilename)
log_debug(_this_file, '%s: Copying file to final destination: "%s"\n' % (self.__class__.__name__, copy_to_dest) )
self.process_ops.exec_cmd(copy_to_dest, as_admin, admin_password)
log_debug(_this_file, '%s: Deleting tmp file: "%s"\n' % (self.__class__.__name__, delete_tmp) )
self.process_ops.exec_cmd(delete_tmp)
else:
raise Exception("No SSH session active, cannot save file remotely")
def send_warning(self, msg):
grt.log_debug("Wizard", "WARNING: %s\n" % msg)
self._handle_task_output("WARNING", msg, "")
def send_error(self, msg):
grt.log_debug("Wizard", "ERROR: %s\n" % msg)
self._handle_task_output("ERROR", msg, "")
def send_info(self, msg):
grt.log_debug("Wizard", msg + "\n")
self._handle_task_output("INFO", msg, "")
def get_log_destination(self):
dest = {}
if self.ctrl_be.is_sql_connected(
): # If server is up, query the destination from there
if self.ctrl_be.server_version < (
5, 1, 6): # Logging to TABLE was introduced in v5.1.6
try:
result = self.ctrl_be.exec_query(
"SHOW VARIABLES LIKE 'log'")
if not result.nextRow():
return dest
except:
return dest
self.server_profile.log_output = 'FILE' if result.stringByName(
"Value") == 'ON' else 'NONE'
log_debug(
_this_file, '%s: log_output = %s\n' %
(self.__class__.__name__, self.server_profile.log_output))
else:
try:
result = self.ctrl_be.exec_query(
"SHOW VARIABLES LIKE 'log_output'")
if not result.nextRow():
return dest
except:
return dest
self.server_profile.log_output = result.stringByName("Value")
if 'FILE' in self.server_profile.log_output and 'TABLE' in self.server_profile.log_output:
def open_remote_file(path):
import wb_admin_ssh, wb_server_control
ssh = wb_admin_ssh.WbAdminSSH()
ssh.wrapped_connect(
self.server_profile,
wb_server_control.PasswordHandler(
self.server_profile))
sftp = ssh.client.open_sftp()
if not ssh.is_connected():
raise IOError, ''
sftp.open(path)
# Can't read logs from files if admin is disabled:
if not self.server_profile.admin_enabled:
dest['general_log'] = 'TABLE'
dest['slow_log'] = 'TABLE'
log_debug(
_this_file, '%s: log_output = %s\n' %
(self.__class__.__name__, dest))
return dest
# Try to prioritize the files if they are readable
if not getattr(self, 'stored_general_log_source_choice',
None):
if self.server_profile.general_log_file_path:
try:
open(
self.server_profile.general_log_file_path
) if self.server_profile.is_local else open_remote_file(
self.server_profile.general_log_file_path)
dest['general_log'] = 'FILE'
except:
dest['general_log'] = 'TABLE'
else:
dest['general_log'] = 'TABLE'
self.stored_general_log_source_choice = dest[
'general_log']
else:
dest[
'general_log'] = self.stored_general_log_source_choice
if not getattr(self, 'stored_slow_log_source_choice',
None):
if self.server_profile.slow_log_file_path:
try:
open(
self.server_profile.slow_log_file_path
) if self.server_profile.is_local else open_remote_file(
self.server_profile.slow_log_file_path)
dest['slow_log'] = 'FILE'
except:
dest['slow_log'] = 'TABLE'
else:
dest['slow_log'] = 'TABLE'
self.stored_slow_log_source_choice = dest['slow_log']
else:
dest['slow_log'] = self.stored_slow_log_source_choice
log_debug(
_this_file,
'%s: log_output = %s\n' % (self.__class__.__name__, dest))
return dest
as_admin = as_admin, admin_password = admin_password)
log_debug(_this_file, '%s: Copying over tmp file to final filename using sudo: %s -> %s\n' % (self.__class__.__name__, tmp_name, filename) )
self._copy_file(source = tmp_name, dest = filename, as_admin = as_admin, admin_password = admin_password)
log_debug(_this_file, '%s: Copying file done\n' % self.__class__.__name__)
tmp.close()
except Exception, exc:
log_error(_this_file, '%s: Exception caught: %s\n' % (self.__class__.__name__, str(exc)) )
if tmp:
tmp.close()
raise
else:
target_dir = splitpath(filename)[0]
if not os.path.exists(target_dir):
log_debug(_this_file, '%s: Target directory "%s" does not exist\n' % (self.__class__.__name__, target_dir ) )
raise InvalidPathError("The directory %s does not exist" % target_dir)
if not self.is_dir_writable(target_dir):
log_debug(_this_file, '%s: Target directory "%s" is not writable\n' % (self.__class__.__name__, target_dir) )
raise PermissionDeniedError("Cannot write to target directory")
if os.path.exists(filename) and backup_extension:
log_debug(_this_file, '%s: Target file "%s" exists, creating backup\n' % (self.__class__.__name__, filename) )
# backup config file
self._copy_file(filename, filename+backup_extension)
try:
f = open(filename, 'w')
except OSError, err:
if err.errno == errno.EACCES:
raise PermissionDeniedError("Could not open file %s for writing" % filename)
def get_log_destination(self):
dest = {}
if self.ctrl_be.is_sql_connected(): # If server is up, query the destination from there
if self.ctrl_be.server_version < (5, 1, 6): # Logging to TABLE was introduced in v5.1.6
try:
result = self.ctrl_be.exec_query("SHOW VARIABLES LIKE 'log'")
if not result.nextRow():
return dest
except:
return dest
self.server_profile.log_output = 'FILE' if result.stringByName("Value")=='ON' else 'NONE'
log_debug(_this_file, '%s: log_output = %s\n' % (self.__class__.__name__, self.server_profile.log_output) )
else:
try:
result = self.ctrl_be.exec_query("SHOW VARIABLES LIKE 'log_output'")
if not result.nextRow():
return dest
except:
return dest
self.server_profile.log_output = result.stringByName("Value")
if 'FILE' in self.server_profile.log_output and 'TABLE' in self.server_profile.log_output:
def open_remote_file(path):
import wb_admin_ssh, wb_server_control
ssh = wb_admin_ssh.WbAdminSSH()
ssh.wrapped_connect(self.server_profile, wb_server_control.PasswordHandler(self.server_profile))
sftp = ssh.client.open_sftp()
if not ssh.is_connected():
raise IOError, ''
sftp.open(path)
# Can't read logs from files if admin is disabled:
if not self.server_profile.admin_enabled:
dest['general_log'] = 'TABLE'
dest['slow_log'] = 'TABLE'
log_debug(_this_file, '%s: log_output = %s\n' % (self.__class__.__name__, dest) )
return dest
# Try to prioritize the files if they are readable
if not getattr(self, 'stored_general_log_source_choice', None):
if self.server_profile.general_log_file_path:
try:
open(self.server_profile.general_log_file_path) if self.server_profile.is_local else open_remote_file(self.server_profile.general_log_file_path)
dest['general_log'] = 'FILE'
except:
dest['general_log'] = 'TABLE'
else:
dest['general_log'] = 'TABLE'
self.stored_general_log_source_choice = dest['general_log']
else:
dest['general_log'] = self.stored_general_log_source_choice
if not getattr(self, 'stored_slow_log_source_choice', None):
if self.server_profile.slow_log_file_path:
try:
open(self.server_profile.slow_log_file_path) if self.server_profile.is_local else open_remote_file(self.server_profile.slow_log_file_path)
dest['slow_log'] = 'FILE'
except:
dest['slow_log'] = 'TABLE'
else:
dest['slow_log'] = 'TABLE'
self.stored_slow_log_source_choice = dest['slow_log']
else:
dest['slow_log'] = self.stored_slow_log_source_choice
log_debug(_this_file, '%s: log_output = %s\n' % (self.__class__.__name__, dest) )
return dest
def save_file_content_and_backup(self, filename, content, backup_extension, as_admin = False, admin_password = None):
log_debug(_this_file, '%s: Saving file "%s" with backup (sudo="%s")\n' % (self.__class__.__name__, filename, str(as_admin)) )
if as_admin:
tmp_name = self.tempdir+"\\wbfilesavetmp"
tmp = open(tmp_name, "w+b")
try:
log_debug(_this_file, '%s: Writing file contents to tmp file "%s"\n' % (self.__class__.__name__, tmp_name) )
tmp.write(content)
tmp.close()
if backup_extension and os.path.exists(filename):
#dprint_ex(1, "Creating backup of %s to %s" % (filename, filename+backup_extension))
#self._copy_file(source = filename, dest = filename + backup_extension,
# as_admin = as_admin, admin_password = admin_password)
# Create backup and copy over file to final destination in a single command
# This is done because running copy twice, would bring up the UAC dialog twice
script = "copy /Y %s %s && copy /Y %s %s" % (quote_path_win(filename), quote_path_win(filename + backup_extension),
quote_path_win(tmp_name), quote_path_win(filename))
log_debug(_this_file, '%s: Creating backup and commiting tmp file: "%s"\n' % (self.__class__.__name__, script) )
output = []
res = self.process_ops.exec_cmd(script,
as_admin = True,
admin_password = admin_password,
output_handler = lambda line, l= output: l.append(line)
)
if res != 0:
output = "\n".join(output)
raise RuntimeError("Error while executing '%s'. Output = '%s'" % (script, output))
else:
log_debug(_this_file, '%s: Copying over tmp file to final filename using sudo: %s -> %s\n' % (self.__class__.__name__, tmp_name, filename) )
self._copy_file(source = tmp_name, dest = filename, as_admin = as_admin, admin_password = admin_password)
log_debug(_this_file, '%s: Delete tmp file "%s"\n' % (self.__class__.__name__, tmp_name) )
# delete tmp file
## BIZARRE STUFF GOING ON HERE
# commenting out the following line, will make something in committing config file change fail
# even tho the copies happen before this line.. wtf
# os.remove(tmp_name)
log_debug(_this_file, '%s: Done.\n' % self.__class__.__name__)
except Exception, exc:
log_error(_this_file, '%s: Exception caught: %s\n' % (self.__class__.__name__, str(exc)) )
if tmp:
tmp.close()
raise
def __init__(self, ctrl_be, server_profile, running, cpu_widget):
self.ctrl_be = ctrl_be
self.ssh = None
self.cpu = 0
self.mtx = threading.Lock()
self.running = running
self.cpu_widget = cpu_widget
self.settings = server_profile
self.remote_admin_enabled = self.settings.uses_ssh
if not self.remote_admin_enabled:
return
self.ctrl_be.add_me_for_event("shutdown", self)
#upload script. Get local name, open ftp session and upload to the directory
# where mysql.ini is.
self.script = None
self.ssh = ctrl_be.open_ssh_session_for_monitoring()
(dirpath, code) = self.ssh.exec_cmd("cmd /C echo %USERPROFILE%") # %APPDATA% is n/a for LocalService
# which is a user sshd can be run
dirpath = dirpath.strip(" \r\t\n")
if code == 0 and dirpath is not None and dirpath != "%USERPROFILE%":
script_path = App.get().get_resource_path("mysql_system_status_rmt.vbs")
filename = "\"" + dirpath + "\\mysql_system_status_rmt.vbs\""
log_debug('%s:%s.__init__()' % (_this_file, self.__class__.__name__),
'Script local path is "%s". Will be uploaded to "%s"\n' % (script_path, filename) )
if script_path is not None and script_path != "":
#print "Uploading file to ", filename
try:
f = open(script_path)
self.ssh.exec_cmd("cmd /C echo. > " + filename)
maxsize = 1800
cmd = ""
for line in f:
line = line.strip("\r\n")
tline = line.strip(" \t")
if len(tline) > 0:
if tline[0] != "'":
if len(cmd) > maxsize:
self.ssh.exec_cmd("cmd /C " + cmd.strip(" &"))
self.ssh.exec_cmd("cmd /C echo " + line + " >> " + filename)
cmd = ""
else:
cmd += "echo " + line + " >> " + filename
cmd += " && "
if len(cmd) > 0:
self.ssh.exec_cmd("cmd /C " + cmd.strip(" &"))
cmd = ""
self.script = "cscript //NoLogo " + filename + " /DoStdIn"
#run ssh in a thread
log_debug2('%s:%s.__init__()' % (_this_file, self.__class__.__name__), 'About to run "%s"\n' % self.script)
self.chan = None
self.out = ""
self.read_thread = threading.Thread(target=self.ssh.exec_cmd, args=(self.script, Users.CURRENT, None, self.reader, 1, self.save_channel))
self.read_thread.setDaemon(True)
self.read_thread.start()
except IOError, e:
self.ssh.close()
self.ssh = None
raise e
def __del__(self): log_debug(_this_file, "Closing SSH connection") self.close()
def log_debug(msg):
tb = traceback.extract_stack(limit=2)
grt.log_debug("%s:%s:%s"%(os.path.basename(tb[-2][0]),tb[-2][2],tb[-2][1]), msg)
def send_info(self, msg):
grt.log_debug("Wizard", msg)
self._handle_task_output("INFO", msg, "")
def send_error(self, msg):
grt.log_debug("Wizard", "ERROR: "+msg)
self._handle_task_output("ERROR", msg, "")
def send_warning(self, msg):
grt.log_debug("Wizard", "WARNING: "+msg)
self._handle_task_output("WARNING", msg, "")