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)
