def turnIndexToUniq(tname, idxname): if uSysDB.DBType != uSysDB.PgSQL: return con = uSysDB.connect() tab = uDBSchema.getTable(tname, con) idx = tab.getIndex(idxname) if idx is None: uLogging.debug("%s: no such index, it's ok", idxname) return cur = con.cursor() cur.execute("SELECT oid FROM pg_class WHERE relname = %s", tname) row = cur.fetchone() if not row: uLogging.err("Table %s does not exist", tname) return toid = row[0] cur.execute( "SELECT relname, conname FROM pg_constraint c JOIN pg_class r ON (r.oid = c.conrelid) WHERE c.confrelid = %s", toid) fks = [(uDBSchema.getTable(row[0], con), row[1]) for row in cur.fetchall()] fks = [(x[0], x[0].getConstraint(x[1])) for x in fks] for t, fk in fks: uLogging.debug("Temporarily dropping %s", fk) t.dropConstraint(fk.name, con) tab.dropIndex(idxname, con) tab.addConstraint(uDBSchema.UniqueKey(idxname, idx.columns), con) for t, fk in fks: uLogging.debug("Restoring %s", fk) t.addConstraint(fk, con)
def handle_async_exec_error(exit_code, task_item, check_cmd_args, check_request_result): cluster_upgrade_err_pattern = re.compile("ERROR CODE: (.+)") cluster_upgrade_error_parsed = cluster_upgrade_err_pattern.search(check_request_result["out"]) if cluster_upgrade_error_parsed is not None: app_code = int(cluster_upgrade_error_parsed.group(1)) if app_code == 1604: uLogging.info("Agent already upgraded on host {host}".format(host=task_item.host)) elif app_code == 3010: # node needs to restart uLogging.info("Some files were locked during upgrade and a restart of node {host} is required " "to complete the installation. \nWARNING: You can do it later " "but before the next upgrade.".format(host=task_item.host)) else: # try to interpret MSI code uLogging.err("Agent update on host {host} failed. MSI error: {error_description} ({error_id})." "\n{manual_upgrade_instruction}".format( host=task_item.host, error_description=msi_errors.get(app_code, '<unknown error>'), error_id=app_code, manual_upgrade_instruction=get_manual_upgrade_inst(exit_code, task_item.host))) raise uUtil.ExecFailed(command=" ".join(check_cmd_args), status=check_request_result['exit_code'], out=check_request_result['out'], err=check_request_result['err']) else: uLogging.err("Agent update on host {host} failed:\nUnknown Error\n{manual_upgrade_instruction}".format( host=task_item.host, manual_upgrade_instruction=get_manual_upgrade_inst(exit_code, task_item.host))) raise uUtil.ExecFailed(command=" ".join(check_cmd_args), status=check_request_result['exit_code'], out=check_request_result['out'], err=check_request_result['err'])
def loadProgress(self, config): try: self.progress = uUtil.loadObj(config.cache, "progress.dat", PreparationProgress) except Exception, e: uLogging.err("exception while loading progress: %s" % e) self.progress = PreparationProgress()
def check_mount_bind_bug(): """Check that is possible to perform "mount --bind" command. This bug appear on PCS containers with outdated systemd. It was fixed (POA-99460). """ # It reproducible only on containers with RHEL/CentOS 7.2, so we need to check this. if determinePlatform().osverfull[:2] != ('7', '2') or not os.path.isfile("/proc/user_beancounters"): return True # Trying to bindmount inner_dir to outer_dir, raising an error if "mount --bind" failed. outer_dir = "/root/bind_test_dir_outer" inner_dir = "/root/bind_test_dir_inner" uUtil.execCommand(["mkdir", outer_dir, inner_dir]) try: uLogging.debug("Testing execution of \"mount --bind\" command started. ") uUtil.execCommand(["mount", "--bind", outer_dir, inner_dir]) # Waiting 2 sec after mounting (as pointed out by Vasily Averin), # if inner_dir is absent in mtab, umount will return an error. time.sleep(2) uUtil.execCommand(["umount", inner_dir]) uUtil.execCommand(["rmdir", outer_dir, inner_dir]) uLogging.debug("Testing execution of \"mount --bind\" command successfully passed. ") return True except: uUtil.execCommand(["rmdir", outer_dir, inner_dir]) uLogging.err('Precheck error: "mount --bind" command executed idly.\n') import sys sys.tracebacklimit = 0 raise Exception('\nUnable to complete the installation. ' 'The precheck error occurred: "mount --bind" command executed idly. ' 'This functionality is critical for the named daemon. If you use Virtuozzo container, ' 'then probably the systemd version in your OS repository is outdated. In this case, ' 'you should update your systemd to the version "systemd-219-19.el7_2.3" or higher ' 'so the "mount --bind" can be executed correctly.')
def logLastException(): """ logs last exception with stack trace """ import traceback uLogging.debug("Error trace:") uLogging.debug(traceback.format_exc()) uLogging.err(str(sys.exc_info()[1]))
def handle_win_upgrade_unknown_hcl_error(exit_code, task_item, check_cmd_args, check_request_result): uLogging.err("AsyncExec error detection failed. Exit code: {exit_code}; output: {raw_output}".format( exit_code=check_request_result["exit_code"], raw_output=check_request_result["out"] )) uLogging.err("Agent update on host {host} failed.\n{manual_upgrade_instruction}".format( host=task_item.host, manual_upgrade_instruction=get_manual_upgrade_inst(exit_code, task_item.host) )) raise uUtil.ExecFailed(command=" ".join(check_cmd_args), status=check_request_result['exit_code'], out=check_request_result['out'], err=check_request_result['err'])
def getHaMasterAddr(pghaSettings): run = lambda cmd: uUtil.runLocalCmd(cmd) cmdStatusSql = """PGPASSWORD=%s PGCONNECT_TIMEOUT=10 psql postgres -t -A --username=%s --host=%s --port=%d -c "select pg_is_in_recovery() " """ # detect status of PG on DB node A try: aNodeRecoveryState = run(cmdStatusSql % (pghaSettings.monitorAccountPasswd, pghaSettings.monitorAccount, pghaSettings.aDbNode, pghaSettings.haBackendPort)).strip() except Exception, ex: uLogging.err("Failed to request DB node A with error '%s'" % ex.message) raise Exception("PostgreSQL on DB node A did not response. Both DB nodes should be operable")
def add_script_from_file(self, script): try: action_id, action_owner, action_type = parse_action_filename( os.path.basename(script)) except Exception, e: uLogging.err( ' *** Upgrade action script %s will be skipped owing to malformed script name' % script) # skip unsupported files in upgrade action directories raise
def waitTasksComplete(where): con = uSysDB.connect() cur = con.cursor() prev_num = 0 task_status_dict = { # According to modules/platform/u/EAR/poakernel-ejb/src/main/clientidl/TaskManagement.idl "n": "not queued", "u": "unprocessed", "b": "being scheduled", "f": "failed", "s": "rescheduled", "e": "running", "r": "restarted", "c": "canceled" } while True: cur.execute( "SELECT t.name, t.task_id, t.status FROM tm_tasks t LEFT JOIN tm_task_references ref " "ON (t.task_id = ref.task_id) WHERE " + where + " and t.status != 'c' ORDER BY task_id") tasks = [(row[0], row[1], row[2]) for row in cur.fetchall()] if not tasks: return tasks_printable = "\n".join([ "\tName: {0},\tID: {1},\tStatus: {2} ({3})".format( row[0], row[1], task_status_dict[row[2]], row[2]) for row in tasks ]).strip("[]") uLogging.debug("Current unfinished tasks: \n" + tasks_printable) failed = [t for t in tasks if t[2] not in ('s', 'u', 'e', 'b')] if failed: for t in failed: name, tid, status = t cur2 = con.cursor() cur2.execute( "SELECT action_output FROM tm_logs WHERE task_id = %s ORDER BY finished DESC", tid) row = cur2.fetchone() if row: output = str(row[0]) else: output = ' no output' uLogging.err("%s(id=%s) failed with %s", name, tid, output) raise Exception("There are failed update tasks") if prev_num != len(tasks): # nm, tid, status = tasks[0] running = ', '.join([t[0] for t in tasks if t[2] == 'e']) uLogging.info("%s (%s more to go)", running, len(tasks)) else: sys.stdout.write('.') sys.stdout.flush() prev_num = len(tasks) time.sleep(1)
def waitRequestComplete(request_id, operation, doWait): waiting = False api = OpenAPI() default_tried = False sys_stderr_written = False while True: request_status = api.pem.getRequestStatus(request_id=request_id) if request_status['request_status'] == 1: if not waiting: uLogging.info("%s (request %s) is not completed yet.", operation, request_id) elif request_status['request_status'] == 2: uLogging.err("%s operation failed", operation) for e in request_status['status_messages']: uLogging.err('%s', e) doWait = False waiting = False else: if sys_stderr_written: sys.stderr.write('\n') uLogging.info("%s finished successfully", operation) return True if doWait and not waiting: uLogging.info("Waiting for %s completion (Interrupt to abort)", operation) waiting = True if waiting: try: sys.stderr.write('.') sys_stderr_written = True time.sleep(3) except KeyboardInterrupt, e: doWait = False if doWait: continue default_error_action = uAction.get_default_error_action() if default_error_action and not default_tried: action = default_error_action default_tried = True else: action = uDialog.askVariants( 'What should I do', '(A)bort', ['(A)bort', '(R)echeck', '(I)gnore', '(W)ait']) if action in ('(A)bort', 'abort'): raise Exception('%s failed' % operation) elif action in ('(I)gnore', 'ignore'): if sys_stderr_written: sys.stderr.write('\n') return False elif action in ('(W)ait'): doWait = True elif action in ('(R)echeck', 'retry'): waiting = doWait = False
def dropIdentity(tab, con): identity_column = first(tab.columns, lambda x: isinstance(x.type, uDBTypes.SerialType)) if identity_column is None: uLogging.err("There is no identity column on table %s", tab.name) return cur = con.cursor() cur.execute("ALTER TABLE `%s` ALTER `%s` DROP DEFAULT" % (tab.name, identity_column.name)) cur.execute("DROP SEQUENCE `%s`" % seq(tab.name))
def ln_cp(src, dst): try: if os.path.isdir(dst): dst = os.path.join(dst, os.path.basename(src)) if os.path.isfile(dst): os.chmod(dst, stat.S_IWRITE) os.unlink(dst) shutil.copy2(src, dst) except Exception, e: uLogging.err("%s while copying %s to %s", e.__class__, src, dst) raise
def process_result(self): host = self.pool_result.task_item.host upgrade_result = self.pool_result.result without_exception = not isinstance(upgrade_result, Exception) empty_result = upgrade_result is None if without_exception and not empty_result and upgrade_result is True: self.successful = True elif empty_result: uLogging.err("Slave {host} upgrade failed. Check details in log.".format(host=host)) else: uLogging.err("Slave {host} upgrade failed. Details: \n{error_as_text}".format( host=host, error_as_text=self.error_as_text))
def call(self, verb, path, headers=None, data=None, cert=None, rheaders=None): if isinstance(data, JsonNode): data = repr(data) elif (isinstance(data, (dict, list))): data = json.dumps(data) url = self.url + path uLogging.info('%s %s ...' % (verb, url)) if headers and self.verbose: uLogging.debug('Request headers:\n\t%s' % "\t".join(["%s: %s" % (h, headers[h]) for h in headers.keys()])) if data and self.verbose: uLogging.debug("Request:\n%r" % data) if not(headers): headers = dict() req = urllib2.Request(url, headers=headers, data=data) req.get_method = lambda: verb resp = None try: if cert: opener = urllib2.build_opener(HTTPSClientAuthHandler(cert, cert)) resp = opener.open(req) else: if _PYTHON_2_7_9_COMPAT: context = ssl._create_unverified_context() resp = urllib2.urlopen(req, context=context) else: resp = urllib2.urlopen(req) except urllib2.HTTPError, error: contents = error.read() uLogging.err('API Error:') uLogging.err(contents) # APS Exceptions have the following structure (example): # { # "code": 500, # "type": "APS::Hosting::Exception", # "message": "Limit for resource ..." # } # In order to allow simple processing of this exception like # ('something' in error.aps.message) we convert this exception # to JSON directly here. error.aps = API.APSExcStruct() if len(contents): error.aps = json.loads(contents, object_hook=lambda x: JsonNode(**x)) raise error
def verifyPostgresCertificate(pgsqlOnMaster): uLogging.info("Make sure PostgreSQL server.crt satisfies the installation requirements according to the KB '%s'" % PG_CERT_VERIFY_KB_URL) serverCrtPath = pgsqlOnMaster.get_data_dir() + "/server.crt" runOnMaster = pgsqlOnMaster.get_commander() # make sure certificate exists try: checkExists = runOnMaster("[ -e '%s' ] && echo 'OK'" % serverCrtPath) if checkExists.strip() != 'OK': raise Exception("Certificate '%s' not found" % serverCrtPath) except Exception, ex: uLogging.err(ex.message) exceptionMsg = "Failed to validate existence of '%s' with error '%s'. Please refer to the KB %s" % (serverCrtPath, ex.message, PG_CERT_VERIFY_KB_URL) uLogging.warn("\n%s\n%s\n%s" %( "*" * 150, exceptionMsg, "*" * 150)) raise Exception(exceptionMsg)
def handle_win_upgrade_failure_on_http(task_item, http_respond_out): op_error = uHCL.readHCLOperationError(http_respond_out) if op_error["code"] < 0: uLogging.debug("HCL operation result: \n{op_error}".format(op_error=pformat(op_error))) raise Exception(upgrade_in_progress_msg.format(host=task_item.host)) else: uLogging.err("HTTP request failed. " "Error code: {code}; message: {message}, type: {type}, module: {module}".format( code=op_error["code"], message=op_error["message"], type=op_error["type"], module=op_error["module"])) uLogging.err("Agent update on host {host} failed.\n{manual_upgrade_instruction}".format( host=task_item.host, manual_upgrade_instruction=get_manual_upgrade_inst(0, task_item.host))) raise Exception("Agent upgrade on host {host} failed. " "Check error messages above.".format(host=task_item.host))
def update_timezone(self): if self._has_updater(): uLogging.debug('Update time zones: begin') try: workspace_path = self._create_workspace() self._update_timezone(workspace_path) uLogging.debug('Update time zones: end') except: uLogging.save_traceback() uLogging.err('Update time zones: end (fail)') finally: self._remove_workspace(workspace_path) else: uLogging.debug( '%s not found, skipping time zone update (%s)' % (self._get_updater_filename(), self._get_updater_path()))
def tryCheckExec(instructions): actionBlacklist = [ ] # list upgrade action that should not be verified by pyChecker os.environ['PYCHECKER'] = '--limit 8196 --maxlines 8196 --maxlocals 8196' try: global pychecker_import, orig_import if pychecker_import is None: orig_import = __builtin__.__import__ import pychecker.checker as checker pychecker_import = __builtin__.__import__ else: __builtin__.__import__ = pychecker_import except ImportError, e: uLogging.err("Pychecker is not installed: not checking python scripts") return
def schedule_update_windows_slave(task_item): # Preparing HCL request for scheduling agent upgrade via asyncExec.exe remote_temp_dir = get_remote_temp_dir(task_item.host) remote_async_exec_path = get_remote_async_exec_path(task_item.host) schedule_request = uHCL.Request(host_id=task_item.host.host_id, auto_export=True) schedule_request.mkdir(remote_temp_dir) schedule_request.fetch( srcfile=posixpath.basename(task_item.paagent_dist_url), urls=[posixpath.dirname(task_item.paagent_dist_url)], dstvar="archive" ) schedule_request.extract("${archive}", remote_temp_dir) schedule_cmd_args = [ remote_async_exec_path, '--delay 10', '--cluster', '--checkmutex {mutex}'.format(mutex=agent_msi_mutex), '--anchor {anchor}'.format(anchor=agent_anchor_name), '"{paagent_exe} /c /qn /l {update_log} REBOOT=Suppress AUTO_UPGRADE=1"'.format( paagent_exe=PAAGENT_EXE_FILENAME, update_log=WIN_UPGRADE_LOG) ] # With 'retvar' option we will catch return code and will not fail if it is not eq 0 schedule_request.command(remote_async_exec_path, schedule_cmd_args, cwd=remote_temp_dir, stderr="err", stdout="out", retvar="exit_code") uLogging.debug("Scheduling agent upgrade on Windows host {host}.".format(host=task_item.host)) uLogging.debug("Executing {async_exec_launch}".format(async_exec_launch=" ".join(schedule_cmd_args))) schedule_result = schedule_request.performCompat() schedule_return_code = int(schedule_result['exit_code']) if schedule_return_code < 100: if schedule_return_code == 12: uLogging.info( "Agent upgrade on host {host} is running already. Skip scheduling.".format(host=task_item.host) ) elif schedule_return_code != 0: err_msg = "Scheduling windows update on host {host} failed. AsyncExec exit code: {exit_code}; " \ "stdout: {out}; stderr: {err}".format(host=task_item.host, exit_code=schedule_result['exit_code'], out=schedule_result['out'], err=schedule_result['err']) uLogging.err(err_msg) raise uUtil.ExecFailed(command=" ".join(schedule_cmd_args), status=schedule_result['exit_code'], out=schedule_result['out'], err=schedule_result['err'])
def readPropertiesFile(f, fail_on_errors=True, to_array=False): rv = [] line_no = 1 for line in f: if line.strip().startswith('#') or not line.strip(): continue pmatch = __prop_line_pattern.match(line) if pmatch is None: errmsg = "%d: '%s' bad property line" % (line_no, line) if fail_on_errors: raise Exception(errmsg) else: uLogging.err("%s", errmsg) else: rv.append((pmatch.group(1), pmatch.group(2))) line_no += 1 return rv if to_array else dict(rv)
def __assignPkgIds(output, pkglist): i = 0 line = output.readline() while line: if i < len(pkglist): pkg = pkglist[i] outp = mass_import_out_pattern.match(line) if not outp: uLogging.err("Cannot understand ppm_ctl output: '%s'", line) oldnew, pkg_id = outp.group(1), outp.group(2) pkg.pkg_id = int(pkg_id) if oldnew == 'n': pkg.old = False elif oldnew == 'o': pkg.old = True else: pkg.old = None i += 1 line = output.readline()
def update_binary(pkg, rootpath): def do_unpack(pkg, rootpath): uLogging.info("Updating %s (%s)", pkg.package, pkg.tarball_location) arc = tarfile.open(pkg.tarball_location, 'r') for tarinfo in arc: arc.extract(tarinfo, path=rootpath) arc.close() if pkg.tarball_location is not None: try: do_unpack(pkg, rootpath) except IOError, e: if Const.isWindows() and e.errno == errno.EACCES: uLogging.err( "Cannot unpack, file is probably locked. retrying") time.sleep(1) do_unpack(pkg, rootpath) else: raise
def dropIdentity(tab, con): identity_column = first(tab.columns, lambda x: isinstance(x.type, uDBTypes.SerialType)) if not identity_column: uLogging.err("There is no identity column on table %s", tab.name) return icname = identity_column.name cur = con.cursor() oid = _getTableOid(tab.name, cur) cur.execute( "SELECT ft.name, fk.name FROM sys.foreign_keys fk JOIN sys.objects ft ON (ft.object_id = fk.parent_object_id) WHERE fk.referenced_object_id = %s", oid) fks = [(getTable(row[0], con), row[1]) for row in cur.fetchall()] fks = [(x[0], x[0].getConstraint(x[1])) for x in fks] for ft, fk in fks: ft.dropConstraint(fk.name, con) constraints = [x for x in tab.constraints if x.refers(icname)] for c in constraints: tab.dropConstraint(c.name, con) was_nullable = identity_column.nullable new_column = Column(icname, uDBTypes.IntType(), True) indices = [x for x in tab.indexes if x.refers(icname)] for i in indices: tab.dropIndex(i.name, con) tab.renameColumn(icname, icname + '_old', con) tab.addColumn(new_column, con) cur.execute("UPDATE %s SET %s = %s" % (tab.name, icname, icname + '_old')) tab.dropColumn(icname + '_old', con) if not was_nullable: tab.dropNullable(icname, con) for c in constraints: tab.addConstraint(c, con) for i in indices: tab.addIndex(i, con) for ft, fk in fks: ft.addConstraint(fk, con)
def configure(cls): uLogging.info('Running billing configure') request = uHCL.Request(cls.get_host_id(), user='******', group='root') request.command(cls.configureScript, stdout='stdout', stderr='stderr', retvar='retvar') output = request.perform() # w/a for POA-114760 (null error message if script outrput is too long). Need to check retvar explicitly, if output['retvar'] != '0': uLogging.err( "Command '%s' failed. Return code: %s, \n stdout: %s \n stderr: %s" % (cls.configureScript, output['retvar'], output['stdout'], output['stderr'])) raise Exception( "Command '%s' failed. Return code: %s, \n stdout: %s \n stderr: %s" % (cls.configureScript, output['retvar'], output['stdout'][-4048:], output['stderr'][-4048:])) uLogging.debug('done, output \n%s' % output['stdout']) return output
def fn(*args, **kwargs): for i in range(1, n + 1): uLogging.info( 'N-times retried action "{action_name}", try {i} of {n}...'. format(action_name=fun.__name__, i=i, n=n)) try: return fun(*args, **kwargs) except Exception, e: if i >= n: uLogging.err( 'Failed n-times retried action "{action_name}"') raise e uLogging.debug( 'Got exception in action "{action_name}", retrying after timeout {timeout} sec. ' 'Exception message: \n{e}'.format(action_name=fun.__name__, timeout=timeout, e=e)) time.sleep(timeout)
def __init__(self, con, dep_id, dep_type): self.same_host = dep_type == 'H' self.dep_id = dep_id cur = con.cursor() cur.execute("SELECT name, ctype, version FROM dep_packages WHERE dep_id = %s", self.dep_id) row = cur.fetchone() if row: self.package = (row[0], row[1], row[2]) else: self.package = None cur.execute( "SELECT i.interface_id, i.service_type FROM dep_interfaces di JOIN interfaces i ON (i.interface_id = di.interface_id) WHERE di.dep_id = %s", self.dep_id) row = cur.fetchone() if row: self.interface = (row[0], row[1]) else: self.interface = None if self.package is None and self.interface is None: uLogging.err("%d: could not determine dependency kind", dep_id)
def checkURLAccessFromServiceNodes(hosts_to_check, url, in_precheck=False, proxy=""): problem_hosts = [] for host in hosts_to_check: try: proxy_arg = "" if proxy: proxy_arg = "--proxy %s" % proxy request = uHCL.Request(host.host_id, user='******', group='root') # HTTP 301 redirect for requesting folders w/o trailing slash request.command( "curl -o /dev/null --silent --head -L --write-out '%%{http_code}' %s %s" % (url, proxy_arg), stdout='stdout', stderr='stderr', valid_exit_codes=range(0, 100)) output = request.performCompat() if output['stdout'] != "200": uLogging.err('URL "%s" is not accessible from host "%s": HTTP response code is "%s"' % ( url, host, output['stdout'])) problem_hosts += [(host, 'HTTP response code for %s is %s' % (url, output['stdout']))] except Exception, e: uUtil.logLastException() problem_hosts += [(host, str(e))] except:
def __yum_local_deploy_package(rpms, command, **kwargs): file_names = [] for rkey in rpms.keys(): if rkey == tuple([rpms[rkey]["info"].name, "RHEL", determinePlatform().osverfull[0]]): rpm_file = rpms[rkey]['path'] if not rpm_file: if 'strict' in kwargs and kwargs['strict'] is False: continue else: raise Exception('Unable to find rpm %s in distribution at %s' % (rpms[rkey]["info"].name, rpm_file)) file_names.append(rpm_file) if file_names: command = ["yum", "-y", "--nogpgcheck", command] + file_names try: uUtil.execCommand(command) except uUtil.ExecFailed as e: uLogging.err("""Failed to install [%s]:\n Command '%s' failed\n Check if YUM is properly installed and configured, note that you can use option --repo-base-url to customize Central PA YUM URL.""" % (' '.join(file_names), " ".join(command))) raise e
def tryCheckSQL(instructions): actions = [ x for x in instructions.preparation.actions if isinstance(x, SQLScript) ] actions += [ x for x in instructions.pre.actions if isinstance(x, SQLScript) ] actions += [ x for x in instructions.prepkg.actions if isinstance(x, SQLScript) ] actions += [x for x in instructions.actions if isinstance(x, SQLScript)] actions += [ x for x in instructions.post.actions if isinstance(x, SQLScript) ] actions += [ x for x in instructions.cleanup.actions if isinstance(x, SQLScript) ] # need set some value for ConcatOperator when it is not initialized naturally (when one have database connected) import uSysDB if not uSysDB.ConcatOperator: uSysDB.ConcatOperator = '||' errors = False for action in actions: for stmt in action.parsed_code(): kind, text = stmt if kind in ('CREATE', 'ALTER', 'DROP'): uLogging.err("Action:%s, not portable statement '%s'", action.id, stmt) errors = True elif kind in ('BEGIN', 'COMMIT', 'ROLLBACK'): uLogging.warn( '%s statements are ignored, <SQL> action always implicitly begins and commits transaction', kind) if errors: raise Exception('Non portable SQL in some actions')
def done(self, success=True): now = time.time() if not self.whats: uLogging.err("Internal error / unmatched do/done") return st, what, args = self.whats[-1] del self.whats[-1] wargs = what % args totals = now - st time_str = pretty_timing(totals) if success: uLogging.debug( "%s<%s finished %s [%s]", self.phase is not None and ('[' + self.phase + '] ') or '', '-' * (len(self.whats) + 1), wargs, time_str) else: uLogging.debug( "%s<%s %s failed [%s]", self.phase is not None and ('[' + self.phase + '] ') or '', '-' * (len(self.whats) + 1), wargs, time_str)