def execute_cmd(self, cmd, progress_notify):
p1 = cmd_executor(cmd)
self.process_handle = p1
pct = 0.0
progress_notify(pct, "0 %")
while p1 and p1.returncode is None:
p1.poll()
char = p1.stdout.read(1)
if char == "0":
continue
else:
if char == ".":
pct = pct + 0.03
else:
try:
num = float(char)
except ValueError:
#it means that child process pass away, we can do nothing with it
break
if num == 1.0 and pct > 3.0:
progress_notify(pct, "Finished")
break
pct = num / 10.0
progress_notify(pct, "%d %%" % int(pct * 100))
sout, serr = p1.communicate()
self.returncode = p1.returncode
if self.returncode != 0:
if serr != "":
raise Exception(serr)
raise grt.UserInterrupt()
def execute_script(connection, script, log):
connection = get_connection(connection)
ranges = grt.modules.MysqlSqlFacade.getSqlStatementRanges(script)
for start, length in ranges:
if grt.query_status():
raise grt.UserInterrupt()
statement = script[start:start + length]
try:
grt.send_info("Execute statement", statement)
grt.log_debug3("DbMySQLFE", "Execute %s\n" % statement)
connection.execute(statement)
except db_utils.QueryError, exc:
if log:
entry = grt.classes.GrtLogEntry()
entry.owner = log
entry.name = str(exc)
entry.entryType = 2
log.entries.append(entry)
grt.send_warning("%s" % exc)
grt.log_error("DbMySQLFE",
"Exception executing '%s': %s\n" % (statement, exc))
return False
except Exception, exc:
if log:
entry = grt.classes.GrtLogEntry()
entry.owner = log
entry.name = "Exception: " + str(exc)
entry.entryType = 2
log.entries.append(entry)
grt.send_warning("Exception caught: %s" % exc)
grt.log_error("DbMySQLFE",
"Exception executing '%s': %s\n" % (statement, exc))
return False
def run(self):
try:
while self.process.poll() is None:
if self._owner.query_cancel_status():
raise grt.UserInterrupt("Canceled by user")
line = self.process.stdout.readline()
if line is not None:
type, _, msg = line.strip().partition(":")
if type in ("PROGRESS", "ERROR", "BEGIN", "END"):
self.result_queue.put((type, msg))
else:
self.result_queue.put(("LOG", line))
# Processes any remaining output
output = self.process.stdout.read()
lines = output.split("\n")
for line in lines:
if line is not None:
type, _, msg = line.strip().partition(":")
if type in ("PROGRESS", "ERROR", "BEGIN", "END"):
self.result_queue.put((type, msg))
else:
self.result_queue.put(("LOG", msg))
if self.process.returncode != 0:
self.result_queue.put(
("DONE",
"Worker exited with status %s" % self.process.returncode))
else:
self.result_queue.put(("DONE", None))
except grt.UserInterrupt, e:
self._owner.send_info(
"Copy task interrupted by user, terminating %s..." % self.name)
self.terminate()
self.result_queue.put(("INTERRUPTED", None))
def check_interruption():
"""Checks if the user is requesting to cancel an operation in progress.
Call this from time to time so that the actual cancel requests can be handled
"""
if grt.query_status():
raise grt.UserInterrupt()
def _migrate_data(self):
# update the label with the number of rows to copy here, since this is in the main thread
total = 0
table_count = len (self._working_set);
for task in self._working_set.values():
total += task.get("row_count", 0)
self.create_transfer_log(task["target_table_object"])
self.send_info("") # newline
if self._working_set:
thread_count = self.main.plan.state.dataBulkTransferParams.get("workerCount", 2)
self.send_info("Migrating data...")
self._log_progress_text = False
self._migrating_data = True
try:
succeeded_tasks = self._transferer.migrate_data(thread_count, self._working_set)
finally:
self._log_progress_text = True
self._migrating_data = False
self.send_info("") # newline
self.send_info("Data copy results:")
fully_copied = 0
self._tables_to_exclude = list()
self._count_of_failed_tables = 0
for task in self._working_set.values():
info = succeeded_tasks.get(task["target_schema"]+"."+task["target_table"], None)
row_count = task.get("row_count", 0)
if info:
ok, count = info
else:
count = 0
ok = False
if ok and count == row_count:
fully_copied = fully_copied + 1
target_table = "%s.%s" % (task["target_schema"], task["target_table"])
message = "Succeeded : copied %s of %s rows from %s.%s" % (count, row_count,task["source_schema"], task["source_table"])
self.add_log_entry(0, target_table, message)
self.send_info("- %s.%s has succeeded (%s of %s rows copied)" % (task["target_schema"], task["target_table"], count, row_count))
self._tables_to_exclude.append(task["target_table"])
else:
self.send_info("- %s.%s has FAILED (%s of %s rows copied)" % (task["target_schema"], task["target_table"], count, row_count))
self._count_of_failed_tables = self._count_of_failed_tables + 1
self.send_info("%i tables of %i were fully copied" % (fully_copied, table_count))
if self._transferer.interrupted:
raise grt.UserInterrupt("Canceled by user")
if self._resume:
self.send_info("Click [Retry] to retry copying remaining data from tables")
else:
self.send_info("Nothing to be done")
def getSchemaNames(connection):
"""Returns a list of schemas for the given connection object."""
names = []
result = get_connection(connection).executeQuery("SHOW DATABASES")
if grt.query_status():
raise grt.UserInterrupt()
while result and result.nextRow():
names.append(result.stringByIndex(1))
return names
def getTableNames(connection, schema):
"""Returns a list of the tables in the given schema for the given connection object."""
names = []
result = get_connection(connection).executeQuery("SHOW TABLES FROM `%s`" % schema)
if grt.query_status():
raise grt.UserInterrupt()
while result and result.nextRow():
names.append(result.stringByIndex(1))
return names
def check_interruption(cls):
if grt.query_status():
raise grt.UserInterrupt()