def verify_prerequisite(self, uut, abstract, steps, timeout):
'''Learn Ops object and verify the requirements.
If the requirements are not satisfied, then skip to the next
testcase.
Args:
uut (`obj`): Device object.
abstract (`obj`): Abstract object.
steps (`step obj`): aetest step object
timeout (`timeout obj`): Timeout Object
Returns:
None
Raises:
pyATS Results
'''
self.timeout = timeout
try:
self.pre_snap = self.mapping.learn_ops(device=uut,
abstract=abstract,
steps=steps,
timeout=self.timeout)
except Exception as e:
self.skipped('Cannot learn the feature',
from_exception=e,
goto=['next_tc'])
for stp in steps.details:
if stp.result.name == 'skipped':
self.skipped('Cannot learn the feature', goto=['next_tc'])
self.print_local_verifications()
# get and store the member priority list
try:
out = ShowPlatform(device=uut).parse()
# inital priority storage
priority_dict = {}
priority_list = []
if 'slot' in out:
for slot in out['slot']:
for rp in out['slot'][slot]['rp']:
if out['slot'][slot]['rp'][rp]['role'] == 'Member':
priority_dict[slot] = \
out['slot'][slot]['rp'][rp]['priority']
priority_list.append(
out['slot'][slot]['rp'][rp]['priority'])
if len(list(set(priority_list))) != 1:
# sorted the slot priority
priority_list = sorted(priority_dict.items(),
key=lambda x: x[1])
# update the verify_ops requirements
for ops, requirements in self.mapping._verify_ops_dict.items(
):
if 'platform' in ops:
self.mapping._verify_ops_dict[ops][
'requirements'].append([
'slot', 'rp',
'{}'.format(priority_list[-1][0]),
'swstack_role', 'Standby'
])
else:
# update the verify_ops requirements
for ops, requirements in self.mapping._verify_ops_dict.items(
):
if 'platform' in ops:
self.mapping._verify_ops_dict[ops][
'requirements'].append([
'slot', 'rp', '(?P<members>.*)',
'swstack_role', '(Standby|Member)'
])
except Exception as e:
log.warn('Cannot get the member priority. \n{}'.format(str(e)))
def learn_system(device, steps, platform_pts=None):
"""Learn and store the system properties
Args:
testbed (`obj`): Testbed object
Returns:
None
Raises:
pyATS Results
"""
# learn show version
if not platform_pts:
with steps.start(
"Store image type/router type from 'show version' on {}".
format(device.name)) as step:
try:
output = ShowVersion(device=device).parse()
device.image_type = output['version']['image_type']
device.router_type = output['version']['rtr_type']
except Exception as e:
log.warning(e)
step.passx('Cannot get required router info on {}'.format(
device.name))
log.info('Image type: {}\nRouter type: {}'.format(
device.image_type, device.router_type))
# learn show version
with steps.start(
"Store switches info from 'show platform' on {}".format(
device.name)) as step:
req = {
'active':
[['slot', '(?P<switch>.*)', 'rp', '(.*)', 'role', 'Active']],
'standby':
[['slot', '(?P<switch>.*)', 'rp', '(.*)', 'role', 'Standby']],
'members':
[['slot', '(?P<switch>.*)', 'rp', '(.*)', 'role', 'Member']]
}
try:
output = ShowPlatform(device=device).parse()
ret = get_requirements(requirements=req, output=output)
device.active = ret['active'][0]['switch']
device.standby = ret['standby'][0]['switch']
device.members = [i['switch'] for i in ret['members']]
except Exception as e:
log.warning(e)
step.passx('Cannot get required router info on {}'.format(
device.name))
log.info(
'Active Switch: {}\nStandby Switch: {}\nMember Switch: {}'.
format(device.active, device.standby, device.members))
else:
with steps.start("Store image type/router type from PTS on {}".format(
device.name)) as step:
try:
# device.image_type = platform_pts.image_type
device.image_type = 'developer image'
device.router_type = platform_pts.rtr_type
except Exception as e:
log.warning(e)
step.passx('Cannot get required router info on {}'.format(
device.name))
log.info('Image type: {}\nRouter type: {}'.format(
device.image_type, device.router_type))
with steps.start("Store switches info from PTS on {}".format(
device.name)) as step:
req = {
'active':
[['slot', 'rp', '(?P<switch>.*)', 'swstack_role', 'Active'],
['slot', 'rp', '(?P<switch>.*)', 'state', 'Ready']],
'standby':
[['slot', 'rp', '(?P<switch>.*)', 'swstack_role', 'Standby'],
['slot', 'rp', '(?P<switch>.*)', 'state', 'Ready']],
'members':
[['slot', 'rp', '(?P<switch>.*)', 'swstack_role', 'Member'],
['slot', 'rp', '(?P<switch>.*)', 'state', 'Ready']]
}
try:
ret = get_requirements(requirements=req, output=platform_pts)
device.active = ret['active'][0]['switch']
device.standby = ret['standby'][0]['switch']
device.members = [i['switch'] for i in ret['members']]
except Exception as e:
log.warning(e)
step.passx('Cannot get required switches info on {}'.format(
device.name))
log.info(
'Active Switch: {}\nStandby Switch: {}\nMember Switch: {}'.
format(device.active, device.standby, device.members))
def verify_show_platform(self, uut, steps, timeout):
'''Attempting Platform Manager: Log Check for show platform on Router
Args:
uut (`obj`): Device object.
steps (`step obj`): aetest step object
timeout (`timeout obj`): Timeout Object
Returns:
None
Raises:
pyATS Results
'''
try:
output = ShowPlatform(device=uut).parse()
except Exception as e:
self.skipped('Cannot get platform info from "show platform"',
from_exception=e)
# get switch environment status
with steps.start(
'Get system platform infomration'
' from all switches',
continue_=True) as step:
requirements = {
'slot_number': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'slot',
'(?P<slot_number>\d+)'
]],
'ports': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'ports',
'(?P<ports>\d+)'
]],
'model': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'name',
'(?P<model>.*)'
]],
'serial_number': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'sn',
'(?P<serial_number>.*)'
]],
'mac_address': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'mac_address',
'(?P<mac_address>.*)'
]],
'hw_ver': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'hw_ver',
'(?P<hw_ver>.*)'
]],
'sw_ver': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'sw_ver',
'(?P<sw_ver>.*)'
]],
'role': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'role',
'(?P<role>(Active|Standby|Member))'
]],
'priority': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'priority',
'(?P<priority>.*)'
]],
'state': [[
'slot', '(?P<stack>.*)', 'rp', '(.*)', 'state',
'(?P<state>.*)'
]],
'switch_mac_address':
[['main', 'switch_mac_address', '(?P<switch_mac_address>.*)']],
'mac_persistency_wait_time': [[
'main', 'mac_persistency_wait_time',
'(?P<mac_persistency_wait_time>.*)'
]],
}
try:
ret = get_requirements(requirements=requirements,
output=output)
except Exception as e:
step.failed("Cannot get stack required info from show platform"
"\nrequirements: {}".format(requirements),
from_exception=e)
# check switch status and mode
with steps.start(
'Check if all Switches have all information '
'requires',
continue_=True) as step:
# check active switch pid vid and sn info
for key in ['switch_mac_address', 'mac_persistency_wait_time']:
if key not in ret:
step.failed('Show platform output is not complete! '
'Missing {}'.format(key))
else:
log.info('The {k} is {v}'.format(k=key, v=ret[key]))
requirements.pop(key)
try:
verify_requirements(reqs=requirements,
full_stack=self.full_stack,
keys_dict=ret)
except Exception as e:
step.failed(
"Show platform output is not complete! Missing switch number"
.format(requirements),
from_exception=e)
