def _run_invalid(self, data): error_reported = False for branch in data.body: result = TryBranchResult(branch.type, branch.patterns, branch.variable) with StatusReporter(branch, result, self._context, run=False, suppress=True): runner = BodyRunner(self._context, run=False, templated=self._templated) runner.run(branch.body) if not error_reported: error_reported = True raise ExecutionFailed(data.error) raise ExecutionFailed(data.error)
def get_chd_files(self): ''' Get *.chd files on all nodes, meanwhile identify new generated stripe files since the last time. ''' # Clear list of new stripe files self.new_file_list = [] eval_cmd = 'eval `ssh-agent`;eval `ssh-add ~/.ssh/dpnid`;' for node in self.node_list: ssn_cmd = 'ssn %s \'find /data0?/cur -name "*.chd"\'' % node cmd = eval_cmd + ssn_cmd result = self.ssh.run_command(cmd) if result[2]: LOG.error('Fail to get chd file list on node %s.' % node) raise ExecutionFailed('Fail to get chd file on %s.' % node) for line in result[0].split('\n'): # Ignore other files if not line.endswith('.chd'): continue # Ignore existing stripe files if (node, line) in self.file_list: continue # Add new stripe files into two lists self.file_list.append((node, line)) self.new_file_list.append((node, line))
class ForLoop(_BaseKeyword): def __init__(self, forstep, templated=False): _BaseKeyword.__init__(self, self._get_name(forstep), type='for') self.vars = forstep.vars self.items = forstep.items self.range = forstep.range self.keywords = Keywords(forstep.steps, templated) self._templated = templated def _get_name(self, data): return '%s %s [ %s ]' % (' | '.join(data.vars), 'IN' if not data.range else 'IN RANGE', ' | '.join(data.items)) def run(self, context): self.starttime = get_timestamp() context.start_keyword(self) error = self._run_with_error_handling(self._validate_and_run, context) self.status = self._get_status(error) self.endtime = get_timestamp() self.elapsedtime = get_elapsed_time(self.starttime, self.endtime) context.end_keyword(self) if error: raise error def _run_with_error_handling(self, runnable, context): try: runnable(context) except ExecutionFailed, err: return err except DataError, err: msg = unicode(err) context.output.fail(msg) return ExecutionFailed(msg, syntax=True)
def _run_teardown(self, context): if not self.teardown: return None try: name = context.variables.replace_string(self.teardown.name) except DataError, err: return ExecutionFailed(unicode(err), syntax=True)
class ForLoop(BaseKeyword): def __init__(self, forstep, template=None): BaseKeyword.__init__(self, self._get_name(forstep), type='for') self.vars = forstep.vars self.items = forstep.items self.range = forstep.range self.keywords = Keywords(forstep.steps, template) self._templated = bool(template) def _get_name(self, data): return '%s %s [ %s ]' % (' | '.join(data.vars), 'IN' if not data.range else 'IN RANGE', ' | '.join(data.items)) def run(self, context): self.starttime = get_timestamp() context.output.start_keyword(self) try: self._validate() self._run(context) except ExecutionFailed, err: error = err except DataError, err: msg = unicode(err) context.output.fail(msg) error = ExecutionFailed(msg, syntax=True)
def _set_variables(self, context, return_value): try: VariableAssigner(self.assign).assign(context, return_value) except DataError, err: self.status = 'FAIL' msg = unicode(err) context.output.fail(msg) raise ExecutionFailed(msg, syntax=True)
def test_higher_level_setup_err_prevents_all_lower_level_setups(self): self.errs.suite_setup_err(ExecutionFailed('Terriblesness occured!')) self.errs.start_suite() self._setup_and_teardown_disallowed() self.errs.end_suite() self.errs.start_suite() self._setup_and_teardown_disallowed() self.errs.end_suite()
def compare_something(self, input): self.input = int(input) if self.input < 5: logger.info("Test passed because value %s is lower than 5" % input, also_console=True) elif self.input == 5: logger.warn("%s is equal to 5 and will reach the treshold soon" % input) else: logger.error("The value %s reached treshold 5!!!" % input) raise ExecutionFailed("Value five was reached!!!!")
def test_sibling_errors_dont_affect_each_other(self): self.errs.start_suite() self.errs.suite_setup_err(ExecutionFailed('Terriblesness occured!')) self.errs.start_suite() self._setup_and_teardown_disallowed() self.errs.end_suite() self.errs.end_suite() self.errs.start_suite() self._setup_and_teardown_allowed()
def _should_run_handler(self, data, failures, handler, handler_matched, handler_error): if not self._run or handler_matched or handler_error or data.error: return False, None try: return failures and self._error_is_expected(failures, handler), None except: return False, ExecutionFailed(get_error_message())
def run(self, kw, context): result = KeywordResult(kwname=self.name, libname=self.libname, args=kw.args, assign=kw.assign, type=kw.type) with StatusReporter(context, result): context.fail(self.error) raise ExecutionFailed(self.error, syntax=True)
def _set_variables(self, context, return_value, error): if error: return_value = error.return_value try: self._variable_assigner.assign(context, return_value) except DataError as err: self.status = 'FAIL' msg = unicode(err) context.output.fail(msg) raise ExecutionFailed(msg, syntax=True)
def _run_with_error_handling(self, runnable, context): try: runnable(context) except ExecutionFailed as err: return err except DataError as err: msg = unicode(err) context.output.fail(msg) return ExecutionFailed(msg, syntax=True) else: return None
def _run_setup_or_teardown(self, data): if not data: return None try: name = self._variables.replace_string(data.name) except DataError as err: if self._settings.dry_run: return None return ExecutionFailed(message=err.message) if name.upper() in ('', 'NONE'): return None try: KeywordRunner(self._context).run(data, name=name) except ExecutionStatus as err: return err
def replace_renderer_policy_version(renderer_policy_json, next_version): """ Find and replace version of given renderer-policy json :param renderer_policy_json: renderer policy :param next_version: version to be written into given policy :return: plain renderer policy with replaced version """ try: renderer_policy_json["renderer-policy"]["version"] = next_version except KeyError: msg = "Expected version element not found in given renderer-policy" logger.debug(msg) raise ExecutionFailed(msg) return json.dumps(renderer_policy_json)
def _run_excepts(self, data, error, run): for branch in data.except_branches: try: run_branch = run and self._should_run_except(branch, error) except DataError as err: run_branch = run = False error = ExecutionFailed(str(err)) result = TryBranchResult(branch.type, branch.patterns, branch.variable) if run_branch: if branch.variable: self._context.variables[branch.variable] = str(error) error = self._run_branch(branch, result, run=True) run = False else: self._run_branch(branch, result, run=False) return error
def _run_teardown(self, context): if not self._handler.teardown: return None try: name = context.variables.replace_string(self._handler.teardown.name) except DataError as err: return ExecutionFailed(err.message, syntax=True) if name.upper() in ('', 'NONE'): return None try: StepRunner(context).run_step(self._handler.teardown, name) except PassExecution: return None except ExecutionFailed as err: return err return None
def resolve_sxp_node_is_enabled(sxp_node_json): """ Try to get value of leaf enabled :param sxp_node_json: sxp node operational state :return: enabled value """ enabled = None try: for node in sxp_node_json["node"]: enabled = node["sxp-node:enabled"] except KeyError: msg = "No sxp node content present - can not read value of enabled" logger.debug(msg) raise ExecutionFailed(msg) return enabled
def remove_endpoint_timestamp(endpoint_json): """ Remove timestamp from given endpoint node and return plain text (for simple comparison) :param endpoint_json: endpoint node from DS/operational :return: plain text without timestamp """ try: for address_endpoint in endpoint_json["endpoints"][ "address-endpoints"]["address-endpoint"]: del address_endpoint["timestamp"] except KeyError: msg = "No endpoint present - can not wipe timestamp" logger.debug(msg) raise ExecutionFailed(msg) return json.dumps(endpoint_json)
def _run_teardown(self, context): if not self.teardown: return None try: name = context.variables.replace_string(self.teardown.name) except DataError as err: return ExecutionFailed(unicode(err), syntax=True) if name.upper() in ('', 'NONE'): return None runner = KeywordRunner(context) try: runner.run_keyword(self.teardown, name) except PassExecution: return None except ExecutionFailed as err: return err return None
def _run_teardown(self, context): if not self.teardown: return None try: name = context.variables.replace_string(self.teardown.name) except DataError as err: return ExecutionFailed(unicode(err), syntax=True) if name.upper() in ('', 'NONE'): return None kw = Keyword(name, self.teardown.args, type='teardown') try: kw.run(context) except PassExecution: return None except ExecutionFailed as err: return err return None
def _get_failure(self, exc_type, exc_value, exc_tb, context): if exc_value is None: return None if isinstance(exc_value, ExecutionFailed): return exc_value if isinstance(exc_value, DataError): msg = exc_value.message context.fail(msg) return ExecutionFailed(msg, syntax=exc_type is not VariableError) exc_info = (exc_type, exc_value, exc_tb) failure = HandlerExecutionFailed(ErrorDetails(exc_info)) if failure.timeout: context.timeout_occurred = True context.fail(failure.full_message) if failure.traceback: context.debug(failure.traceback) return failure
def replace_netconf_node_host(netconf_node_json, node_name, host_value): """ Replace host value in netconf node configuration :param netconf_node_json: netconf node configuration :param node_name: required node-name value :param host_value: required host value :return: plain text with replaced host value """ try: for node in netconf_node_json["node"]: node["netconf-node-topology:host"] = host_value node["node-id"] = node_name except KeyError: msg = "No host found in given netconf node config" logger.debug(msg) raise ExecutionFailed(msg) return json.dumps(netconf_node_json)
def get_node_list(self): ''' Get node list of the server. avmaint ping --xmlperline=5 | egrep "<nodelist" | grep ONLINE <nodelist id="0.2" state="ONLINE" count="54"> <nodelist id="0.1" state="ONLINE" count="49"> <nodelist id="0.0" state="ONLINE" count="58"> ''' cmd = 'avmaint ping --xmlperline=5 | egrep "<nodelist" | grep ONLINE' result = self.ssh.run_command(cmd) if result[2]: LOG.error('Fail to get node list.') raise ExecutionFailed('Fail to get node list.') for line in result[0].split('\n'): m = re.search(r'id="(\d\.\d{1,2})"', line) if m: self.node_list.append(m.group(1)) if len(self.node_list) > 1: self.is_multi = True
def replace_ip_mgmt_address_in_forwarder(sf_forwarders_json, ip_mgmt_map): """ Find and replace ip-mgmt-address values for corresponding forwarders names :param sf_forwarders_json: sfc forwarders json :param ip_mgmt_map: key=forwarder-name, value=ip-mgmt-address :return: plain sfc forwarders with replaced ip-mgmt-addresses """ try: for sff in sf_forwarders_json["service-function-forwarders"][ "service-function-forwarder"]: sff_name = sff["name"] if sff_name in ip_mgmt_map: sff["ip-mgmt-address"] = ip_mgmt_map[sff_name] except KeyError: msg = "Expected sff not found in given config" logger.debug(msg) raise ExecutionFailed(msg) return json.dumps(sf_forwarders_json)
def check_iso8601_datetime_younger_then_limit(status_timestamp_raw, limit): """ Compare timestamp of given status to given limit, raise exception if status is older or equal to limit :param status_timestamp_raw: json from DS/operational (ise-source status) :param limit: datetime value - status must be younger than this """ logger.debug("limit:{0}".format(limit)) timestamp_raw = status_timestamp_raw # 2016-11-23T13:25:00.733+01:00 status_tstamp = isodate.parse_datetime(timestamp_raw) limit_tstamp = isodate.parse_datetime(limit) limit_tstamp = limit_tstamp.replace(tzinfo=status_tstamp.tzinfo) if status_tstamp <= limit_tstamp: logger.info("status stamp --> {0}".format(status_tstamp)) logger.info("limit --> {0}".format(limit_tstamp)) raise ExecutionFailed( "received status is not up-to-date: {0}".format(status_tstamp))
def _get_failure(self, exc_type, exc_value, exc_tb, context): if exc_value is None: return None if isinstance(exc_value, ExecutionStatus): return exc_value if isinstance(exc_value, DataError): msg = exc_value.message context.fail(msg) syntax = not isinstance(exc_value, (KeywordError, VariableError)) return ExecutionFailed(msg, syntax=syntax) error = ErrorDetails(exc_value) failure = HandlerExecutionFailed(error) if failure.timeout: context.timeout_occurred = True if failure.skip: context.skip(error.message) else: context.fail(error.message) if error.traceback: context.debug(error.traceback) return failure
def _stop_execution_gracefully(self): raise ExecutionFailed('Execution terminated by signal', exit=True)
def _stop_execution_gracefully(self): if not self._error_reported: self._error_reported = True raise ExecutionFailed('Execution terminated by signal', exit=True)
def __exit__(self, exc_type, exc_val, exc_tb): if isinstance(exc_val, DataError): msg = exc_val.message self._context.fail(msg) raise ExecutionFailed(msg, syntax=True)