def cap_slot_status():
"""Capture slot status
capture slot status from cached data 'slot_status' and sync up to '/tftpboot/slot_status/slot_status'
:return:
"""
time.sleep(1)
log.info('record Slot Status lock...')
with locking.named_priority_lock(lockname='slot_status_lock',
release_timeout=60,
wait_timeout=30 * 60):
slot_status = lib.get_cached_data('slot_status')
log.debug('Current status ')
log.debug('******************')
for i in range(1, 9):
log.info('{}'.format(slot_status[(i - 1) * 12:i * 12]))
log.debug('******************')
slot_status_file = r'/tftpboot/slot_status/slot_status'
return_slot_status = ''
with open(slot_status_file, 'w') as f:
f.close()
for ctr in slot_status:
if ':8-12' in ctr:
return_slot_status += ctr
else:
return_slot_status += ctr + ','
os.system('echo {} >> {}'.format(ctr, slot_status_file))
# log.info('return {}'.format(return_slot_status))
return return_slot_status
def auto_get_model():
"""Get Uut type model
Get automation flag in pre-sequences.
:return:
"""
mm = lib.apdicts.userdict['mm']
uuttype = mm.uut_config.get('MODEL_NUM', 'NA')
# TODO: re-design for no hardcode
uuttype_maps = {
"WS-C3850-24T": "1",
"WS-C3850-48T": "2",
"WS-C3850-24P": "3",
"WS-C3850-48P": "4",
"WS-C3850-24U": "5",
"WS-C3850-48U": "6",
"WS-C3850-12S": "7",
"WS-C3850-24S": "8",
"WS-C3850-24XU": "9",
"WS-C3850-12X48U": "A",
"WS-C3850-12XS": "B",
"WS-C3850-24XS": "C",
}
uut_type = uuttype_maps[uuttype]
slot = "{}-{}".format(
int(lib.get_my_container_key().split('|')[-1].split('_')[0][-2:]),
int(lib.get_my_container_key().split('|')[-1].split('_')[1][:2]))
status = "{}TEST{}".format(
uut_type,
lib.get_cached_data('slot_status')[slot_index[slot]].split(':')[0][-1])
log.info('{}:{}'.format(status, slot))
change_slot_status(slot, status)
return
def get_global_corners(container_key=None):
""" Get Corners
This is strictly a read of the global cache; therefore no locking required.
IMPORTANT: This is done by sequence_definition() so MUST be compatible with Apollo main process.
Global cache key is the station path (i.e. chamber).
:return:
"""
log.debug("Global Corners: get...")
if not container_key:
log.debug("Need to get container key...")
container_key = aplib.get_my_container_key()
S_KEY = '_'.join(container_key.split('|')[:-1])
cc_key = 'chamber_corners_' + S_KEY
try:
log.debug("Chamber corner cache key (get) = {0}".format(cc_key))
corners = aplib.get_cached_data(cc_key)
except (KeyError, apexceptions.ApolloException) as e:
log.exception("Problem with chamber corners in global cache.")
log.exception(e.message)
corners = None
if not corners:
log.error("Chamber corners: ABSENT!")
log.error("Global cache key = {0}".format(cc_key))
log.error(
"Please correct the situation before running the chamber. Inspect UUT product definitions."
)
raise apexceptions.AbortException("Chamber corners: ABSENT!")
else:
log.debug("Chamber corners: PRESENT.")
return corners
def automatic_clear_pre():
"""Automatic Clear Pre
Clear slot status in pre-sequences
pass pre-sequences uuts, clear auto_pass in userdict
fail pre-sequences uuts, record status in local with SN, FAIL steps,
:return:
"""
mm = lib.apdicts.userdict['mm']
current_sernum = mm.uut_config.get('SYSTEM_SERIAL_NUM', 'NOPOWERON')
# Get Step dict
current_status, steps_ret = auto_get_test_status()
slot = "{}-{}".format(
int(lib.get_my_container_key().split('|')[-1].split('_')[0][-2:]),
int(lib.get_my_container_key().split('|')[-1].split('_')[1][:2]))
slot_status = lib.get_cached_data('slot_status')
slot_info = slot_status[slot_index[slot]]
uut_type = slot_info[0]
if current_status != 'PASS':
status = '{}{}{}'.format(uut_type, current_status,
slot_info.split(':')[0][-1])
change_slot_status(slot, status)
for k, v in steps_ret.items():
if 'FAIL' in v:
local_record(current_sernum, slot, status, k)
return
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
pass
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pl = udd.get('product_line').upper()
seq_module = getattr(thismodule, pl + '_sysft')
return seq_module.standard_switch_sequence_definition()
def step__queue_children():
ACTIVECS_KEY, MAXCS_KEY = steps_ess_chamber.get_chamber_slots_keys()
uut_slots = aplib.get_cached_data(ACTIVECS_KEY)
log.debug('Chamber slots staged: {0}'.format(uut_slots))
supercontainer = aplib.get_container_name()
for i, uut_slot in enumerate(uut_slots):
container_name = '{0}:UUT{1:02}'.format(supercontainer, uut_slot)
log.debug("Queued Conatiner = {0}".format(container_name))
aplib.queue_child_container(container_name, test_area=__area__)
return aplib.PASS
def eng_utility_menu_sequence_definition():
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(aplib.get_my_container_key()))
pf = udd.get('product_family').upper()
seq = aplib.get_sequence_definition('{0} {1} SEQ ENG MENU DEBUG'.format(__product_line__, pf), jump_on_error='FINAL')
if pf in SEQ_STEP_MAP:
func = getattr(thismodule, SEQ_STEP_MAP[pf].seq_function_name)
return func(seq, pf, udd)
else:
seq.add_step(err_product_family, kwargs={'pf': pf})
seq.add_step(steps_catalyst.final, name='FINAL')
return seq
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, __area__),
jump_on_error='FINAL')
# ------------------------------------------------------------------------------------------------------------------
# Init
init_seq = seq.add_sequence('INITIALIZATION')
init_seq.add_step(steps_quake.init, name='INIT', kwargs={})
init_seq.add_step(steps_quake.ud_retrieve, name="RETRIEVE UUT DESCRIPTOR")
init_seq.add_step(steps_quake.ud_print_uut_descriptor,
name='PRINT DESCRIPTOR')
init_seq.add_step(steps_quake.ud_print_uut_config, name='PRINT UUT CONFIG')
# Power ON & Boot
# Unit should already be powered up from pre-sequence auto-discovery.
seq.add_step(steps_quake.power_cycle_on,
name='POWER ON BOOT',
group_level=5,
enabled=False)
# Basic Mode
seq.add_step(steps_quake.goto_mode,
name='MODE IOS',
kwargs={'mode': 'IOS'})
# PIDVID Verify
seq.add_step(steps_quake.process_verify_pidvid,
name='PIDVID VERIFY',
jump_on_error='CLEAN UP')
# ------------------------------------------------------------------------------------------------------------------
#
# PUT CODE HERE
#
# ------------------------------------------------------------------------------------------------------------------
# Clean up
final_seq = seq.add_sequence('FINAL', finalization=True)
final_seq.add_step(steps_quake.power_off,
name='POWER OFF',
kwargs={},
group_level=1000)
final_seq.add_step(steps_quake.clean_up, name='CLEAN UP')
final_seq.add_step(steps_quake.final, name='END')
return seq
def on(self, **kwargs):
""" ON
:param kwargs:
:return:
"""
channels = kwargs.get('channels', 'ALL')
wait_for_boot = kwargs.get('wait_for_boot', True)
bypass = False
container_key = aplib.get_my_container_key()
log.info('CONTAINER_KEY:')
log.info('{0}'.format(container_key))
container = container_key.split("|")[-1]
pl, ar, ts, _ = container_key.split("|", 3)
# 1. Check for power dependencies
if self._ud.category == 'MODULAR':
active_modular_name = '_'.join([pl, ar, ts, 'ActiveModular'])
with locking.ContainerPriorityLock('__active_modular__'):
active_modular = aplib.get_cached_data(active_modular_name)
if not active_modular:
log.error("No active modular stations; please activate a UUT for allocation.")
return aplib.FAIL
if container == active_modular[0] and self._uut_conn.status != aplib.STATUS_OPEN:
log.debug("Modular; primary connection for power on.")
bypass = False
else:
log.debug("Modular; shared connection and/or connection already open.")
bypass = True
# 2. Skip power if allowed
if bypass:
log.info("BYPASS: No power cycle.")
return aplib.PASS
# 3. Perform the power operation !!
self.__power_operation(op='ON', channels=channels)
# 4. UUT Boot process
if not wait_for_boot:
log.warning("Skip standard wait for boot after power on.")
return aplib.PASS
aplib.set_container_text('BOOT')
log.info('Booting up unit')
# Standard search for bootup after a power cycle.
time.sleep(5.0)
result, _ = self._mode_mgr.wait_for_boot()
# NOTE: If the UUT is hardwired for "constant on" then this has no effect.
return aplib.PASS if result else (aplib.FAIL, 'UUT wait for boot did not complete.')
def standard_switch_sequence_definition():
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(
aplib.get_my_container_key()))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, __desc__),
jump_on_error='FINAL')
if pf in SEQ_STEP_MAP:
func = getattr(thismodule, SEQ_STEP_MAP[pf].seq_function_name)
return func(seq, pf, udd)
else:
seq.add_step(step__unknown, kwargs={'pf': pf})
seq.add_step(steps_catalyst.final, name='FINAL')
return seq
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(__product_line__, pf, pc, __desc__), jump_on_error='FINAL')
# -------
subseq__init(seq)
#
# PUT DF SEQ HERE !
#
subseq__final(seq)
return seq
def off(self, **kwargs):
""" OFF
:param kwargs:
:return:
"""
channels = kwargs.get('channels', 'ALL')
container_key = aplib.get_my_container_key()
log.info('CONTAINER_KEY:')
log.info('{0}'.format(container_key))
pl, ar, ts, _ = container_key.split("|", 3)
# 1. Check for power dependencies
if self._ud.category == 'MODULAR':
active_modular_name = '_'.join([pl, ar, ts, 'ActiveModular'])
with locking.ContainerPriorityLock('__active_modular__'):
active_modular = aplib.get_cached_data(active_modular_name)
if active_modular:
if len(active_modular) > 1:
log.debug("More than one modular UUT container is active; cannot power off.")
log.debug("Active: {0}".format(active_modular))
return aplib.SKIPPED
elif len(active_modular) == 1:
log.debug("One active modular container left; stay powered on.")
log.debug("Active: {0}".format(active_modular))
return aplib.SKIPPED
else:
log.debug("NO active modular containers!")
log.debug("Power OFF is allowed.")
# 2. Determine OFF state
if self._ud.keep_connected: # or aplib.get_apollo_mode() == aplib.MODE_DEBUG:
log.warning("*" * 50)
log.warning("UUT CONNECTION IS STILL OPEN.\n"
" This can occur on an error, on abort, or intentionally by script.\n"
" If this connection is used by a different container, it will fail to start until"
" the connection is manually closed.\n"
" The connection is typically left in this state for production debug.\n"
" Close the connection when done OR restart this same container.")
log.warning("*" * 50)
return aplib.PASS
# 3. Perform the power operation !!
self.__power_operation(op='OFF', channels=channels)
return aplib.PASS
def standard_modular_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, __desc__),
jump_on_error='FINAL')
if pf in SEQ_STEP_MAP:
func = getattr(thismodule, SEQ_STEP_MAP[pf].seq_function_name)
return func(seq, pf, udd, container)
else:
seq.add_step(err_product_family, kwargs={'pf': pf})
seq.add_step(steps_catalyst.final, name='FINAL')
return seq
def step__clean_up():
""" Main SEQ PASS update status
:return (str): aplib.PASS/FAIL
"""
if 'auto_pass' in lib.apdicts.userdict:
slot = "{}-{}".format(
int(lib.get_my_container_key().split('|')[-2][-2:]),
int(lib.get_my_container_key().split('|')[-1][-2:]))
slot_status = lib.get_cached_data('slot_status')
slot_info = slot_status[slot_index[slot]]
uut_type = slot_info[0]
if lib.apdicts.userdict['auto_pass']:
status = '{}PASS{}'.format(uut_type, slot_info.split(':')[0][-1])
else:
status = '{}FAIL{}'.format(uut_type, slot_info.split(':')[0][-1])
change_slot_status(slot, status)
return
def _linecard_sup_release(self, label=''):
""" Linecard Supervisor Release (INTERNAL)
Use this to release the lock on the SUP which is used for linecard testing.
:return:
"""
# Station path (MUST be associated to ONE CHASSIS!!)
container_key = aplib.get_my_container_key()
container = container_key.split("|")[-1]
pl, ar, ts, _ = container_key.split("|", 3)
sup_num = self.ud.uut_config.get('linecard', {}).get('sup_prime', 1)
# Sup resource
sup_resource_name = '_'.join(
[pl, ar, ts, 'SupLinecardResource_supslot{0}'.format(sup_num)])
active_name = '_'.join([pl, ar, ts, 'ActiveModular'])
log.info("Linecard's Sup Lock Resource: {0} (for {1})".format(
sup_resource_name, label))
sup_lock = getattr(self.ud, 'sup_lock')
if not sup_lock:
log.info("The sup lock resource does not exist.")
log.info("Nothing to release.")
log.warning(
"This could be an error in the sequence not first locking the sup for the container."
)
return False
else:
try:
# Provide a status.
active_linecards = aplib.get_cached_data(active_name)
if active_linecards and container in active_linecards:
log.info("This container is active.")
except Exception as e:
log.warning(e)
# Release it!
self.ud.sup_lock.release()
log.info("*** SUP LOCK RELEASED! ***")
return True
def auto_finish(serial=None, steps=''):
"""Automatic Finish
record test status Pass/Fail in local file
:return:
"""
current_status, steps_ret = auto_get_test_status()
slot = "{}-{}".format(
int(lib.get_my_container_key().split('|')[-1].split('_')[0][-2:]),
int(lib.get_my_container_key().split('|')[-1].split('_')[1][:2]))
slot_status = lib.get_cached_data('slot_status')
slot_info = slot_status[slot_index[slot]]
uut_type = slot_info[0]
status = "{}{}{}".format(uut_type, current_status,
slot_info.split(':')[0][-1])
if current_status != 'PASS':
for k, v in steps_ret.items():
if 'FAIL' in v:
steps = k
local_record(serial, slot, status, steps)
change_slot_status(slot, status)
return
def change_slot_status(slot, status, skip_error=True):
"""Change Slot Status
Change slot status in local file
:param slot:
sample: Station_B_01 = 1-1: first 1 is Rack number , second 1 is Cell number
:param status:
sample: status: Pass, Fail1, Fail2, Idel.
pass: product_name,1-1,Pass
Fail1: product_name,1-1,Fail1,num-num. #num-num:re-test cell
Fail2: product_name,1-1,Fail2
IDEL:
:param skip_error:
:return:
"""
log.info('{} {} change lock...'.format(slot, status))
with locking.named_priority_lock(lockname='slot_status_lock',
release_timeout=60,
wait_timeout=30 * 60):
slot_status = lib.get_cached_data('slot_status')
log.debug('>>>>> ')
for i in range(1, 9):
log.info('{}'.format(slot_status[(i - 1) * 12:i * 12]))
log.debug('>>>>> '.format(slot_status))
if 'ERRO' in slot_status[slot_index[slot]] and skip_error:
log.debug('ERROR cannot change')
else:
if "ERRO" in status:
status = "0ERRO1"
slot_status[slot_index[slot]] = "{}:{}".format(status, slot)
lib.cache_data('slot_status', slot_status)
log.debug('<<<<< ')
for i in range(1, 9):
log.info('{}'.format(slot_status[(i - 1) * 12:i * 12]))
log.debug('<<<<< ')
cap_slot_status()
log.info('Change local OK')
return True
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, __desc__),
jump_on_error='FINAL')
# -------
subseq__init(seq)
# Area Check
seq.add_step(steps_edison.process_area_check,
name='AREACHECK',
kwargs={'previous_area': 'SYSASSY'},
enabled=True,
jump_on_error='FINAL')
seq.add_step(steps_edison.goto_mode,
name='MODE BTLDR INIT',
kwargs={'mode': 'BTLDR'})
seq.add_step(steps_edison.pcamap_read_uut, name='READ UUT INFO')
seq.add_step(steps_edison.process_verify_cmpd,
name='VERIFY CMPD',
kwargs={'eco_type': 'VERIFICATION'})
seq.add_step(steps_edison.process_get_swpid_from_lineid,
name='GET IOS PID')
seq.add_step(steps_edison.ios_get_software_licenses,
name='GET SW LICENSES')
# seq.add_step(steps_edison.process_assign_verify_mac, name='VERIFY MAC')
seq.add_step(steps_edison.process_populate_dsc_pcamap,
name='LOAD DSC PCAMAP',
kwargs={'source_testarea': ['SYSINT', 'SYSASSY']})
seq.add_step(steps_edison.process_verify_clei_eci_label,
name='VERIFY CLEI LABEL',
kwargs={'source_testarea': ['SYSINT', 'SYSASSY']})
seq.add_step(steps_edison.ios_download_images, name='PREPARE IOS IMAGES')
# Bootloader mode
seq.add_step(steps_edison.goto_mode,
name='MODE BTLDR',
kwargs={'mode': 'BTLDR'})
seq.add_step(steps_edison.upgrade_btldr, name='UPGRADE BTLDR')
# Program Top Level PID
seq.add_step(steps_edison.pcamap_program_toplevel_pid,
name='PROGRAM TOP LEVEL PID')
# Linux Mode
seq.add_step(steps_edison.goto_mode,
name='MODE LINUX',
kwargs={
'mode': 'LINUX',
'do_primary_mount': True
})
seq.add_step(steps_edison.linux_set_terminal_width,
name='SET TERMINAL WIDTH')
seq.add_step(steps_edison.ios_remove_default_licenses,
name='DELETE DEFAULT LICENSES')
seq.add_step(steps_edison.ios_install_supplemental_images,
name='INSTALL SUPP IMAGES')
seq.add_step(steps_edison.load_hw_images,
name='DOWNLOAD DIAG IMAGE',
kwargs={'master_list': ['diag']})
# Verify MCU -----------------
mcu_vrfy_subseq = seq.add_sequence('VERIFY MCU')
mcu_vrfy_subseq.add_step(steps_edison.goto_mode,
name='MODE STARDUST - VERIFY MCU',
kwargs={'mode': 'STARDUST'})
mcu_vrfy_subseq.add_step(steps_edison.upgrade_mcu,
name='VERIFY MCU',
kwargs={'verify_only': True})
# Get PSU data----------------
seq.add_step(steps_edison.diags_psu_check, name='GET PSU INFO')
# ----------------------------
# Quack DSC ------------------
quack_dsc_subseq = seq.add_sequence(
'QUACK DATA STACK CABLE', precondition='userdict.get("dsc_installed")')
quack_dsc_subseq.add_step(steps_edison.goto_mode,
name='MODE STARDUST - QUACK DSC',
kwargs={'mode': 'STARDUST'})
quack_dsc_subseq.add_step(steps_edison.pcamap_write_uut_peripheral,
name='WRITE DSC PCAMAP DEV 2',
kwargs={'device_instance': '2'})
quack_dsc_subseq.add_step(steps_edison.pcamap_write_uut_peripheral,
name='WRITE DSC PCAMAP DEV 3',
kwargs={'device_instance': '3'})
quack_dsc_subseq.add_step(steps_edison.quack2_sign_chip,
name='QUACK DSC 2',
kwargs={'device_instance': '2'})
quack_dsc_subseq.add_step(steps_edison.quack2_sign_chip,
name='QUACK DSC 3',
kwargs={'device_instance': '3'})
quack_dsc_subseq.add_step(steps_edison.diags_stackrac_test,
name='STACK RAC TEST')
# ----------------------------
# Config check ---------------
cnf_chk_subseq = seq.add_sequence('CONFIG CHECK')
cnf_chk_subseq.add_step(steps_edison.pcamap_read_uut,
name='READ DEV 1',
kwargs={'device_instance': 1})
cnf_chk_subseq.add_step(steps_edison.pcamap_read_uut,
name='READ DEV 2',
kwargs={'device_instance': 2})
cnf_chk_subseq.add_step(steps_edison.pcamap_read_uut,
name='READ DEV 3',
kwargs={'device_instance': 3})
cnf_chk_subseq.add_step(steps_edison.process_configuration_check,
name='CNF CHECK')
# ----------------------------
# Add tst data ---------------
seq.add_step(steps_edison.process_add_tst_data_for_children,
name='ADD TST DATA FOR COMPONENTS')
# ----------------------------
# Stardust Diag Testing ------
diag_subseq = seq.add_sequence('DIAGNOSTIC TESTS')
diag_subseq.add_step(steps_edison.goto_mode,
name='MODE STARDUST - DIAGNOSTIC',
kwargs={'mode': 'STARDUST'})
diag_subseq.add_step(steps_edison.diags_sysinit, name='SYSINIT')
diag_subseq.add_step(steps_edison.diags_rtc_chkset_test,
name='RTC CHK SET',
kwargs=dict(severity_allowed=400))
diag_subseq.add_step(steps_edison.diags_serdeseye_sif_test,
name='SERDES EYE SIF TEST',
precondition='userdict.get("dsc_installed")')
diag_subseq.add_step(steps_edison.diags_serdeseye_nif_test,
name='SERDES EYE NIF TEST')
diag_subseq.add_step(steps_edison.diags_vmargin_test,
name='VOLTAGE TEST',
kwargs={
'check_only': True,
'margin_level': 'NOMINAL',
'device_instance': 0
})
diag_subseq.add_step(steps_edison.upgrade_fpga, name='UPGRADE FPGA')
# ----------------------------
# IOS install ----------------
ios_install_subseq = seq.add_sequence('IOS INSTALLATION')
ios_install_subseq.add_step(steps_edison.goto_mode,
name='MODE BTLDR - IOS INSTALL',
kwargs={'mode': 'BTLDR'})
ios_install_subseq.add_step(steps_edison.ios_install_main_image,
name='INSTALL MAIN IOS IMAGE')
# ----------------------------
# License Install/Verify -----
lic_subseq = seq.add_sequence('LIC INSTALL AND VERIFY')
lic_subseq.add_step(steps_edison.goto_mode,
name='MODE IOSE - LIC',
kwargs={'mode': 'IOSE'})
lic_subseq.add_step(steps_edison.ios_install_licenses, name='INSTALL LIC')
lic_subseq.add_step(steps_edison.ios_verify_default_licenses,
name='VERIFY LIC')
lic_subseq.add_step(steps_edison.ios_verify_apcount_license,
name='VERIFY APCOUNT LIC')
# ----------------------------
# Verify IOS status ----------
ios_verify_subseq = seq.add_sequence('VERIFY IOS STATUS')
ios_verify_subseq.add_step(steps_edison.goto_mode,
name='MODE IOSE - IOS VERIFY STATUS',
kwargs={'mode': 'IOSE'})
ios_verify_subseq.add_step(steps_edison.process_get_hw_modules_from_lineid,
name='GET HW MODULES')
ios_verify_subseq.add_step(steps_edison.ios_verify_idpro,
name='ID PRO VERIFY')
ios_verify_subseq.add_step(steps_edison.ios_verify_log_for_empty_poe_ports,
name='VERIFY POE LOGS')
ios_verify_subseq.add_step(steps_edison.ios_verify_customer_version,
name='VERIFY IOS VER')
ios_verify_subseq.add_step(steps_edison.ios_check_environments,
name='IOS ENV')
# ----------------------------
# IOS clean up
seq.add_step(steps_edison.ios_clean_up, name='IOS CLEAN UP')
# ------------------------------------------------------------------------------------------------------------------
# Power Cycle and wait for UUT to boot up IOS
seq.add_step(steps_edison.goto_mode,
name='MODE BTLDR - FINAL',
kwargs={'mode': 'BTLDR'})
seq.add_step(
steps_edison.pcamap_cleanup_rommon_params,
name='UNSET PARAMS',
)
seq.add_step(steps_edison.pcamap_set_manual_boot,
name='MANUAL BOOT NO',
kwargs={'manual_boot': False})
seq.add_step(steps_edison.power_cycle_on,
name='POWER CYCLE',
kwargs={'wait_for_boot': False})
seq.add_step(steps_edison.ios_waitfor_cfg_dialog_boot,
name='WAIT FOR IOS BOOT UP')
seq.add_step(steps_edison.power_off, name='POWER OFF')
subseq__final(seq)
return seq
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
psd = udd.get('uut_config', {}).get('prod_seq_def', {})
area = __area__ # udd.get(test_area, None)
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, area),
jump_on_error='FINAL')
# Enable CATS
# seq.adt_enabled = ['cats']
# ------------------------------------------------------------------------------------------------------------------
# Init
init_seq = seq.add_sequence('INITIALIZATION')
init_seq.add_step(steps_franklin.init, name='INIT', kwargs={})
init_seq.add_step(steps_franklin.ud_retrieve,
name="RETRIEVE UUT DESCRIPTOR")
init_seq.add_step(steps_franklin.ud_print_uut_descriptor,
name='PRINT DESCRIPTOR')
init_seq.add_step(steps_franklin.ud_print_uut_config,
name='PRINT UUT CONFIG')
# Area Check
seq.add_step(steps_franklin.process_area_check,
name='AREACHECK',
kwargs={},
enabled=True)
# Power ON & Boot
# Unit should already be powered up from pre-sequence auto-discovery.
# seq.add_step(steps_franklin.power_cycle_on, name='POWER ON BOOT', group_level=5, enabled=False)
# Basic Mode
seq.add_step(steps_franklin.goto_mode,
name='MODE BTLDR',
kwargs={'mode': 'BTLDR'})
# MAC Verify Only
seq.add_step(steps_franklin.process_assign_verify_mac,
name='VERIFY MAC',
kwargs={'assign': False})
# Get RFID Data
seq.add_step(steps_franklin.process_get_rfid_db,
name='GET RFID TID',
enabled=True,
kwargs={})
# ------------------------------------------------------------------------------------------------------------------
# PCAMAP
pcamap_seq = seq.add_sequence('PCAMAP PROGRAMMING', enabled=True)
# Verify CMPD
# TODO: waiting Trac #5852
pcamap_seq.add_step(steps_franklin.process_verify_cmpd,
name='VERIFY CMPD SPROM',
enabled=False,
kwargs={
'force': False,
'cmpd_description': 'SPROM',
'uut_type_key': 'MODEL_NUM',
'part_number_key': 'TAN_NUM',
'part_revision_key': 'TAN_REVISION_NUMBER',
'eco_type': 'VERIFICATION'
})
# PCAMAP Program
pcamap_seq.add_step(steps_franklin.pcamap_write_uut,
name='PCAMAP PROGRAM',
kwargs={
'device_instance': 0,
'memory_type': 'vb'
})
# PIDVID Verify
seq.add_step(steps_franklin.process_verify_pidvid,
name='PIDVID VERIFY',
jump_on_error='CLEAN UP')
# ------------------------------------------------------------------------------------------------------------------
# Load Images
image_load_seq = seq.add_sequence('IMAGE LOADING', enabled=True)
image_load_seq.add_step(steps_franklin.goto_mode,
name='MODE LINUX',
kwargs={'mode': 'LINUX'})
image_load_seq.add_step(steps_franklin.linux_set_network_interface,
name='SET LINUX NET INTF')
image_load_seq.add_step(
steps_franklin.load_hw_images,
name='LOAD HW IMAGES',
kwargs={
'master_list':
['btldr', 'linux', 'diag', 'fpga', 'mcu', 'nic', 'SBC_CFG'],
'force':
False
},
enabled=False)
image_load_seq.add_step(steps_franklin.ios_install_supplemental_images,
name='LOAD IOS SUPPLEMENTAL IMAGES',
enabled=True)
# ------------------------------------------------------------------------------------------------------------------
# Update any Images via stardust
# SBC update will ALWAYS program; turn off for FST.
image_seq = seq.add_sequence('DEVICE IMAGE PROGRAMMING', enabled=True)
image_secboot_seq = image_seq.add_sequence(
'DEVICE IMAGE PROGRAMMING SECBOOT')
image_secboot_seq.add_step(steps_franklin.goto_mode,
name='MODE BTLDR',
kwargs={'mode': 'BTLDR'})
image_secboot_seq.add_step(steps_franklin.upgrade_btldr, name='PROG BTLDR')
image_secboot_seq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
image_secboot_seq.add_step(steps_franklin.upgrade_fpga, name='PROG FPGA')
image_secboot_seq.add_step(steps_franklin.power_cycle_on,
name='POWER ON REBOOT',
kwargs={'contingent': True},
group_level=5)
image_mcu_seq = image_seq.add_sequence('DEVICE IMAGE PROGRAMMING MCU')
image_mcu_seq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
image_mcu_seq.add_step(steps_franklin.diags_switch_mcu_mode,
name='MCU MODE IOS',
kwargs={'kkmode': 'IOS'})
image_mcu_seq.add_step(steps_franklin.upgrade_mcu,
name='PROG MCU',
enabled=False)
image_nic_seq = image_seq.add_sequence('DEVICE IMAGE PROGRAMMING NIC')
image_nic_seq.add_step(steps_franklin.goto_mode,
name='MODE LINUX',
kwargs={'mode': 'LINUX'})
image_nic_seq.add_step(steps_franklin.upgrade_nic,
name='PROG NIC',
enabled=True)
image_sbc_seq = image_seq.add_sequence('DEVICE IMAGE PROGRAMMING SBC')
image_sbc_seq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
image_sbc_seq.add_step(steps_franklin.update_sbc,
name='PROG SBC',
enabled=False)
# ------------------------------------------------------------------------------------------------------------------
# Identity Protection Programming
idpro_seq = seq.add_sequence('IDENTITY PROTECTION')
idpro_main_subseq = idpro_seq.add_sequence('IDENTITY PROTECTION MAINBOARD',
enabled=True)
idpro_main_subseq.add_step(steps_franklin.power_cycle_on,
name='POWER ON REBOOT',
group_level=5)
idpro_main_subseq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
idpro_main_subseq.add_step(steps_franklin.diags_sysinit,
name='DIAG SYSINIT')
idpro_main_subseq.add_step(steps_franklin.x509sudi_sign_certificate,
name='X509 SHA1',
kwargs={'x509_sudi_hash': 'SHA1'},
enabled=True)
idpro_main_subseq.add_step(steps_franklin.act2_sign_chip,
name='ACT2',
kwargs={
'device_instance': 0,
'keytype': 'ACT2-RSA'
},
enabled=True)
idpro_main_subseq.add_step(steps_franklin.act2_sign_chip,
name='ACT2 2099',
kwargs={
'device_instance': 0,
'keytype': 'ACT2-HARSA'
},
enabled=True)
idpro_main_subseq.add_step(steps_franklin.x509sudi_sign_certificate,
name='X509 SHA256',
kwargs={
'x509_sudi_hash': 'SHA256',
'keytype': 'ACT2-RSA'
},
enabled=True)
idpro_main_subseq.add_step(steps_franklin.x509sudi_sign_certificate,
name='X509 SHA256 2099',
kwargs={
'x509_sudi_hash': 'CMCA3',
'keytype': 'ACT2-HARSA'
},
enabled=False)
# Peripherals for special builds only (i.e. proto, etc.).
if psd.get(area, {}).get('idpro_periphs', False):
idpro_peripheral_subseq = idpro_seq.add_sequence(
'IDENTITY PROTECTION PERIPHERALS', enabled=True)
idpro_peripheral_subseq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
idpro_peripheral_subseq.add_step(steps_franklin.diags_sysinit,
name='DIAG SYSINIT')
idpro_peripheral_subseq.add_step(steps_franklin.act2_sign_chip,
name='ACT2 1',
kwargs={
'device_instance': 1,
'keytype': 'ACT2-RSA'
},
enabled=True)
idpro_peripheral_subseq.add_step(steps_franklin.act2_sign_chip,
name='ACT2 2',
kwargs={
'device_instance': 2,
'keytype': 'ACT2-RSA'
},
enabled=True)
idpro_peripheral_subseq.add_step(steps_franklin.act2_sign_chip,
name='ACT2 3',
kwargs={
'device_instance': 3,
'keytype': 'ACT2-RSA'
},
enabled=True)
idpro_peripheral_subseq.add_step(steps_franklin.act2_sign_chip,
name='ACT2 4',
kwargs={
'device_instance': 4,
'keytype': 'ACT2-RSA'
},
enabled=True)
# IOS Boot Test and IdPro Check
idpro_seq.add_step(steps_franklin.goto_mode,
name='MODE IOSE',
kwargs={'mode': 'IOSE'})
idpro_seq.add_step(steps_franklin.ios_verify_idpro,
name='ID PRO VERIFICATION',
kwargs={})
idpro_seq.add_step(steps_franklin.goto_mode,
name='MODE BTLDR',
kwargs={'mode': 'BTLDR'})
idpro_seq.add_step(steps_franklin.process_assign_verify_mac,
name='VERIFY MAC',
kwargs={'assign': False})
# ------------------------------------------------------------------------------------------------------------------
# Power Cycle Testing
seq.add_step(steps_franklin.power_power_cycle_testing,
name='POWER CYCLE TEST')
# ==================================================================================================================
# Main Loop Tests
# ------------------------------------------------------------------------------------------------------------------
fst_loop_seq = seq.add_sequence('SYSTEM LOOP TESTS',
iterations=(aplib.ITERATION_TIME, 30))
fst_loop_seq.iterations.type = aplib.ITERATION_TIME
fst_loop_seq.iterations.value = psd.get(area, {}).get(
'total_loop_time_secs', 1) if psd else 1
fst_loop_seq.add_step(steps_franklin.loop_marker,
name='FST LOOP',
kwargs={'title': 'FST'})
# ------------------------------------------------------------------------------------------------------------------
# Diag Testing
diag_seq = fst_loop_seq.add_sequence('DIAGNOSTIC TESTS', enabled=True)
diag_seq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
diag_seq.add_step(steps_franklin.diags_sysinit, name='SYSINIT')
diag_seq.add_step(steps_franklin.diags_rtc_chkset_test,
name='RTC CHK SET TEST',
kwargs={})
diag_seq.add_step(steps_franklin.diags_psu_check,
name='PSU CHECK',
kwargs={})
diag_seq.add_step(steps_franklin.diags_update_mcu_settings,
name='MCU SETTINGS',
kwargs={})
diag_seq.add_step(steps_franklin.diags_temperature_test,
name='TEMPERATURE TEST',
kwargs={'operational_state': 'diag'},
enabled=True)
diag_seq.add_step(steps_franklin.diags_vmargin_test,
name='VMARGIN TEST',
kwargs={
'device_instance': 0,
'margin_level': 'NOMINAL'
},
enabled=True)
diag_seq.add_step(steps_franklin.diags_fan_test,
name='FAN TEST',
kwargs={},
enabled=True)
diag_seq.add_step(steps_franklin.diags_stackrac_test,
name='STACKRAC TEST',
kwargs={},
enabled=True)
diag_seq.add_step(steps_franklin.diags_serdeseye_sif_test,
name='SERDES EYE SIF TEST',
kwargs={},
enabled=True)
diag_seq.add_step(steps_franklin.diags_serdeseye_nif_test,
name='SERDES EYE NIF TEST',
kwargs={},
enabled=True)
# Diag Testlist build-out
dynamic_sequence_builder.build_diag_testlist_subseq(
diag_seq=diag_seq,
container=container,
udd=udd,
step_module=steps_franklin,
category=None,
enabled=True)
# ------------------------------------------------------------------------------------------------------------------
# Traffic Testing
traf_seq = fst_loop_seq.add_sequence('TRAFFIC TESTS', enabled=True)
traf_seq.add_step(steps_franklin.goto_mode,
name='MODE STARDUST PRETRAF',
kwargs={'mode': 'STARDUST'})
traf_seq.add_step(steps_franklin.diags_sysinit,
name='DIAG SYSINIT PRETRAF')
dynamic_sequence_builder.build_traffic_cases_subseq(
traffic_seq=traf_seq,
container=container,
udd=udd,
step_module=steps_franklin,
category=None,
enabled=True)
seq.add_step(steps_franklin.loop_marker,
name='FST LOOPS DONE',
kwargs={
'title': 'FST (Loops completed)',
'close_loop': True
})
# ==================================================================================================================
# ------------------------------------------------------------------------------------------------------------------
# Power OFF
seq.add_step(steps_franklin.power_off, name='POWER OFF', group_level=1000)
# Clean up
final_seq = seq.add_sequence('FINAL', finalization=True)
final_seq.add_step(steps_franklin.power_off,
name='POWER OFF',
kwargs={},
group_level=1000)
final_seq.add_step(steps_franklin.clean_up, name='CLEAN UP')
final_seq.add_step(steps_franklin.final, name='END')
return seq
def _allocate_card(self,
action,
priority=100,
card_name='card',
keep_last=False):
""" Allocate Card (INTERNAL)
Activating a linecard or Supervisor = start using it.
Deactivating a linecard or Supervisor = done using it and no longer need to talk to the card.
This routine uses an "active card" list maintained in global cache to keep track of all linecards/Supervisors in use.
Also a 'remove from list' is performed on all non-running containers still in the 'active card list'
(could happen with abort or exception w/ no cleanup).
:param (str) action: 'deactivate', 'activate', 'show'
:param (int) priority: lower number is higher priority
:param (bool) keep_last: Future feature (NOT USED); use to keep last container when deactivating to stay
powered on for something else prior to cleanup.
:return: True|False
"""
log.debug("Configuration Data")
self.ud.derive_device_info()
card_config = self.ud.uut_config.get(card_name.lower(), None)
if not card_config:
log.warning("No configuration data for the UUT card: {0}".format(
card_name))
log.warning(
"Please check the card name and the Apollo x_config.py.")
return False
log.debug("Card config = {0}".format(card_config))
container_key = aplib.get_my_container_key()
container = container_key.split("|")[-1]
pl, ar, ts, _ = container_key.split("|", 3)
active_name = '_'.join([pl, ar, ts, 'ActiveModular'])
with locking.ContainerPriorityLock('__active_modular__',
priority=priority):
log.debug("Lock : {0}".format(active_name))
log.debug("Priority: {0}".format(priority))
active_cards = aplib.get_cached_data(active_name)
if active_cards:
idx = active_cards.index(
container) if container in active_cards else -1
else:
active_cards = []
if action == 'activate':
log.debug("Active {0}.".format(card_name))
if not active_cards:
log.debug("First {0} container to use: '{1}'".format(
card_name.lower(), container))
active_cards = [container]
aplib.cache_data(active_name, active_cards)
else:
if container not in active_cards:
log.debug(
"Adding {0} container to the active list: {1}".
format(card_name.lower(), container))
active_cards.append(container)
aplib.cache_data(active_name, active_cards)
else:
log.debug("{0} container already active: {1}".format(
card_name, container))
elif action == 'deactivate':
log.debug("Deactive {0}.".format(card_name))
for c in active_cards:
# Check & remove orphaned containers (not running but still in the active list due to no cleanup).
status = aplib.get_container_status(c)
log.debug("{0:<10} = {1}{2}".format(
c, status, '*' if status != 'RUNNING' else ''))
if status != 'RUNNING':
idx = active_cards.index(c)
active_cards.pop(idx)
if len(active_cards) > 1:
if idx >= 0:
log.info("Deactivating {0} container: '{1}'...".format(
card_name.lower(), container))
active_cards.pop(idx)
aplib.cache_data(active_name, active_cards)
log.info(
"{0} container deactivated.".format(card_name))
else:
log.info("{0} container already deactivated.".format(
card_name))
elif len(active_cards) == 1:
if not keep_last:
log.info(
"Only one {0} container remains active and it will be deactivated."
.format(card_name.lower()))
aplib.cache_data(active_name, [])
else:
log.warning(
"Only one {0} container remains active; deactivate is bypassed."
.format(card_name.lower()))
log.warning(
"This should only be done when the chassis needs to stay powered on."
)
else:
log.info(
"No {0} containers were activated; nothing to deactivate."
.format(card_name.lower()))
elif action == 'show':
log.debug("Show {0}.".format(card_name))
else:
log.error("Unknown action for {0} allocation.".format(
card_name.lower()))
return False
msg = "Active {0}s".format(card_name)
log.info(msg)
log.info("-" * len(msg))
for lc in active_cards:
log.info("{0} {1}".format(lc, '*' if lc == container else ''))
return True
def step__auto_monitor():
"""Auto Monitor
monitor and communicate with Robot
:return:
"""
container = lib.get_pre_sequence_info().containers[0]
log.info('This is Auto[{}]'.format(container[0]))
area = 'SYSBI'
pc = lib.conn.PC
pc.power_on()
log.info('waiting command....')
time.sleep(0.5)
pc.clear_recbuf()
time.sleep(0.5)
out_type = 'X'
while True:
null_seq = []
pc.send('')
if '#' in pc.recbuf:
slot_status = lib.get_cached_data('slot_status')
comm = pc.recbuf.upper()
log.info('received command [{}]'.format(comm))
if comm[-1] != '#':
log.debug('invalid command, skip')
pc.clear_recbuf()
continue
if comm.count('#') > 1:
comm = comm.split('#')[-2] + '#'
log.info('fix command ->{}'.format(comm))
if 'ASK' in comm:
if "ALL#" in comm:
pc.send('{}#'.format(cap_slot_status()))
else:
r = int(comm.split(':')[1].split('_')[0]) - 1
r = 0 if r < 1 else r
action_seq = []
if '_I#' in comm or '_C#' in comm:
in_slot_status = slot_status
action_seq = [
slot for slot in in_slot_status if 'NULL' in slot
]
# log.debug('I output seq is {}, len is {}'.format(action_seq, len(action_seq)))
if len(action_seq) < 2:
action_seq = ['0NI']
elif '_O#' in comm:
out_slot_status = slot_status[
(r + 1) * 12 - 1::-1] + slot_status[(r + 1) * 12:]
if out_type == 'E':
action_seq = [
slot for slot in out_slot_status
if any(ctr in slot for ctr in ['PASS', 'FAIL'])
]
else:
action_seq = [
slot for slot in out_slot_status
if slot[0] in ["0", out_type] and any(
ctr in slot for ctr in ['PASS', 'FAIL'])
]
while action_seq:
if "FAIL1" not in action_seq[0]:
break
else:
null_seq = [
slot for slot in out_slot_status
if 'NULL' in slot
]
if null_seq:
break
else:
action_seq.remove(action_seq[0])
continue
elif '_X#' in comm:
out_slot_status = slot_status[(r + 1) * 12 - 1::-1]
if out_type == 'E':
out_seq = [
slot for slot in out_slot_status if any(
ctr in slot for ctr in ['PASS', 'FAIL2'])
]
else:
out_seq = [
slot for slot in out_slot_status
if slot[0] == out_type and any(
ctr in slot for ctr in ['PASS', 'FAIL2'])
]
idle_seq = [
slot for slot in out_slot_status if 'IDLE' in slot
]
in_seq = [
slot for slot in slot_status if 'NULL' in slot
]
if len(in_seq) < 2:
in_seq = []
action_seq = out_seq + idle_seq + in_seq
if not action_seq:
out_slot_status = slot_status[(r + 1) * 12:]
if out_type == 'E':
out_seq = [
slot for slot in out_slot_status
if any(ctr in slot
for ctr in ['PASS', 'FAIL2'])
]
else:
out_seq = [
slot for slot in out_slot_status
if slot[0] == out_type and any(
ctr in slot
for ctr in ['PASS', 'FAIL2'])
]
idle_seq = [
slot for slot in out_slot_status
if 'IDLE' in slot
]
action_seq = out_seq + idle_seq
elif '_N#' in comm:
out_slot_status = slot_status[
(r + 1) * 12 - 1::-1] + slot_status[(r + 1) * 12:]
null_seq = [
slot for slot in out_slot_status if 'NULL' in slot
]
if null_seq:
action_seq = [
slot for slot in out_slot_status
if 'FAIL1' in slot
]
elif '_R#' in comm:
out_slot_status = slot_status[
(r + 1) * 12 - 1::-1] + slot_status[(r + 1) * 12:]
action_seq = [
slot for slot in out_slot_status if 'IDLE' in slot
]
else:
log.error('Comm format wrong [{}]'.format(comm))
log.info('Action SEQ -> [{}]'.format(action_seq))
action = "0NA"
if action_seq:
for slot in action_seq:
action = slot
if "FAIL1" in action:
null_slot = null_seq[0]
action = action + ',' + null_slot.split(':')[1]
break
if any(ctr in action for ctr in ["IDLE", "PASS", "NULL"]):
action = action.split(':')[0][:5] + ':' + action.split(
':')[1]
log.info('Next action [{}]'.format(action))
pc.send('{}#'.format(action[1:]))
elif '-' in comm and ':' in comm:
slot = comm.split(':')[1].split('#')[0]
status = comm.split(':')[0]
if 'TEST' in status:
station = 'Station'
cell = 'AUTO:UUT{:02}_{:02}'.format(
int(slot.split('-')[0]), int(slot.split('-')[1]))
status = '0TEST{}'.format(2 if 'RE' in status else 1)
pc.send('OK#')
while True:
run_apollo_container(prod_line='UAG_C3K',
area=area,
test_station=station,
container=cell,
mode='PROD')
if lib.get_container_status(cell) == 'RUNNING':
log.info('{} running ok'.format(cell))
break
log.info(
'{} running meet issue, re-start'.format(cell))
continue
change_slot_status(slot, status, False)
continue
elif 'FIN' in status:
slot = comm.split(':')[1].split('#')[0]
log.debug('Remove {} UUT'.format(slot))
status = '0NULL1'
elif 'IDLE' in status:
slot = comm.split(':')[1].split('#')[0]
log.debug('Input IDLE {} UUT'.format(slot))
status = '0IDLE1'
elif 'ERRO' in status:
status = '0ERRO1'
elif 'FAIL' in status:
status = '0FAIL2'
elif 'OPEN0' in status:
status = '0NULL1'
elif 'OPEN1' in status:
status = '0IDLE1'
elif 'OPEN2' in status:
status = '0FAIL2'
else:
log.info('received command [{}]issue'.format(comm))
pc.send('OK#')
change_slot_status(slot, status, False)
elif 'OUTPUT' in comm:
out_type = comm.split(':')[1].split('#')[0]
log.info('Output {} Product'.format(uuttype[out_type]))
pc.send('OK#')
else:
log.info('received invalid command {}'.format(comm))
else:
continue
return lib.PASS
def set_global_profile(forced_profile=None):
""" Set Global Chamber Profile
Used by the UUT Container PRE-SEQ.
This sets the profile to be used by ALL UUTs in the chamber via a global data cache.
IMPORTANT: Global cache key is the station path (i.e. chamber).
Differing product families are allowed to run but their profile selections MUST match; if not then it will abort.
:param (list) forced_profile:
:return:
"""
log.debug("Global Profile: set...")
container = aplib.get_my_container_key()
# Source the profile.
try:
udd = aplib.apdicts.userdict.get('udd')
if not udd:
log.error("The UutDescriptor Dict was not available.")
log.error(
"Please confirm proper application of the application software!"
)
raise Exception("The UutDescriptor Dict was not available.")
chamber_profile = udd.get('chamber_profile')
if forced_profile:
profile = collections.OrderedDict(forced_profile)
log.debug("Chamber Profile Source: FORCED.")
elif chamber_profile:
profile = collections.OrderedDict(chamber_profile)
log.debug("Chamber Profile Source: UUT DESCRIPTOR.")
else:
log.warning(
"No UutDescriptor chamber_profile, or forced_profile available."
)
log.warning(
"Check the product definitions and common definition for 'chamber_profile'."
)
log.warning("The default commercial profile will be used.")
profile = collections.OrderedDict(DEFAULT_PROFILES['commercial'])
except (KeyError, AttributeError):
log.error(
"Chamber profile data is not available or not in correct form.")
return False
log.debug('-' * 50)
log.debug("{0} : Chamber Profile = {1}".format(container, profile))
# Get the current profile definition (possibly set by another container in the same chamber)
# Global cache key is the station path (i.e. chamber)
S_KEY = '_'.join(container.split('|')[:-1])
cp_key = 'chamber_profile_' + S_KEY
with locking.named_priority_lock('__profile__' + S_KEY):
try:
log.debug("Chamber profile cache key (set) = {0}".format(cp_key))
established_profile = aplib.get_cached_data(cp_key)
except (KeyError, apexceptions.ApolloException):
established_profile = None
if not forced_profile:
# Save the product-specific profile selections for use by SEQ.
if not established_profile:
established_profile = profile
aplib.cache_data(cp_key, established_profile)
log.debug(
"*** A new chamber profile set has been established. ***")
# All UUT profile definitions must match. This allows different PIDs in the same chamber BUT requires
# them to all have the same profile definition.
if profile != established_profile:
log.error("Chamber profile: REJECTED!")
log.error(
"There is a mismatch of chamber_profiles in {0}. This is NOT allowed."
.format(container))
log.error(
"Please correct the situation before running the chamber. Inspect UUT product definitions."
)
raise apexceptions.AbortException(
"MISMATCH of chamber profiles in {0}.".format(container))
else:
log.debug("Chamber profile: ACCEPTED. {0}".format(
established_profile))
else:
aplib.cache_data(cp_key, profile)
log.debug("Chamber profile: FORCED. {0}".format(profile))
return True
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, __area__),
jump_on_error='FINAL')
# Enable CATS
# seq.adt_enabled = ['cats']
# ------------------------------------------------------------------------------------------------------------------
# Init
init_seq = seq.add_sequence('INITIALIZATION')
init_seq.add_step(steps_quake.init, name='INIT', kwargs={})
init_seq.add_step(steps_quake.ud_retrieve, name="RETRIEVE UUT DESCRIPTOR")
init_seq.add_step(steps_quake.ud_print_uut_descriptor,
name='PRINT DESCRIPTOR')
init_seq.add_step(steps_quake.ud_print_uut_config, name='PRINT UUT CONFIG')
# Area Check
seq.add_step(steps_quake.process_area_check,
name='AREACHECK',
kwargs={},
enabled=True)
# Power ON & Boot
# Unit should already be powered up from pre-sequence auto-discovery.
seq.add_step(steps_quake.power_cycle_on,
name='POWER ON BOOT',
group_level=5,
enabled=False)
# Basic Mode
seq.add_step(steps_quake.goto_mode,
name='MODE BTLDR',
kwargs={'mode': 'BTLDR'})
# MAC Verify Only
seq.add_step(steps_quake.process_assign_verify_mac,
name='VERIFY MAC',
kwargs={'assign': False})
# Get RFID Data
seq.add_step(steps_quake.process_get_rfid_db,
name='GET RFID TID',
enabled=True,
kwargs={})
# ------------------------------------------------------------------------------------------------------------------
# PCAMAP
pcamap_seq = seq.add_sequence('PCAMAP PROGRAMMING', enabled=True)
# Verify CMPD
# TODO: waiting Trac #5852
pcamap_seq.add_step(steps_quake.process_verify_cmpd,
name='VERIFY CMPD SPROM',
enabled=False,
kwargs={
'force': False,
'cmpd_description': 'SPROM',
'uut_type_key': 'MODEL_NUM',
'part_number_key': 'TAN_NUM',
'part_revision_key': 'TAN_REVISION_NUMBER',
'eco_type': 'VERIFICATION'
})
# PCAMAP Program
pcamap_seq.add_step(steps_quake.pcamap_write_uut,
name='PCAMAP PROGRAM',
kwargs={
'device_instance': 0,
'memory_type': 'vb'
})
# PIDVID Verify
seq.add_step(steps_quake.process_verify_pidvid,
name='PIDVID VERIFY',
jump_on_error='CLEAN UP')
# ------------------------------------------------------------------------------------------------------------------
# PCBP2
# PUT PCBP2 CODE HERE
# ------------------------------------------------------------------------------------------------------------------
# Clean up
final_seq = seq.add_sequence('FINAL', finalization=True)
final_seq.add_step(steps_quake.power_off,
name='POWER OFF',
kwargs={},
group_level=1000)
final_seq.add_step(steps_quake.clean_up, name='CLEAN UP')
final_seq.add_step(steps_quake.final, name='END')
return seq
def standard_switch_common(profile_type):
""" 2C/4C Run Sequence that includes:
1) setup
2) area check
3) chamber startup
4) corner buildup
5) chamber wrapup
5) power off
6) cleanup
:return: seq
"""
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, __area__),
jump_on_error='FINAL')
# Enable CATS
# seq.adt_enabled = ['cats']
# ------------------------------------------------------------------------------------------------------------------
# Init
init_seq = seq.add_sequence('INITIALIZATION')
init_seq.add_step(steps_nyquist.init, name='INIT', kwargs={})
init_seq.add_step(steps_nyquist.ud_retrieve,
name="RETRIEVE UUT DESCRIPTOR")
init_seq.add_step(steps_nyquist.ud_print_uut_descriptor,
name='PRINT DESCRIPTOR')
init_seq.add_step(steps_nyquist.ud_print_uut_config,
name='PRINT UUT CONFIG')
# Chamber Init
# TODO: Trac#6087
seq.add_step(steps_ess_chamber.step__chamber_init,
name='CHAMBER INIT',
kwargs={
'profile_type': profile_type,
'fi_action': 'nopause',
'first_init': False
})
# Area Check
seq.add_step(steps_nyquist.process_area_check,
name='AREACHECK',
kwargs={'previous_area': 'ICT'},
enabled=True)
# MAC Verify Only
seq.add_step(steps_nyquist.process_assign_verify_mac,
name='VERIFY MAC',
kwargs={'assign': False})
# ------------------------------------------------------------------------------------------------------------------
# PCAMAP
pcamap_seq = seq.add_sequence('PCAMAP PROGRAMMING', enabled=True)
# Verify CMPD
# TODO: waiting Trac #5852
pcamap_seq.add_step(steps_nyquist.process_verify_cmpd,
name='VERIFY CMPD SPROM',
kwargs={
'force': False,
'cmpd_description': 'SPROM',
'uut_type_key': 'MODEL_NUM',
'part_number_key': 'MOTHERBOARD_ASSEMBLY_NUM',
'part_revision_key': 'MOTHERBOARD_REVISION_NUM',
'previous_area': 'PCBST',
'eco_type': 'VERIFICATION'
},
enabled=False)
# Chamber Start
seq.add_step(steps_ess_chamber.step__chamber_start,
name='CHAMBER START',
kwargs={})
# --------------------------------------------------------------------------------------------------------------
# Build All Corners
# Example corners = OrderedDict([('NTNV', ('AMBIENT', 'NOMINAL', False)),
# ('HTLV', ('HOT', 'LOW', True)),
# ('LTLV', ('COLD', 'LOW', True))])
if True: # Logic branch for chamber debug (if needed)
corners = steps_ess_chamber.get_global_corners()
for i, corner in enumerate(corners):
temperature = corners[corner][0]
voltage = corners[corner][1]
adt_flag = corners[corner][2]
corner_seq = seq.add_sequence('{0} CORNER'.format(corner),
adt_enabled=adt_flag)
corner_seq.add_step(steps_ess_chamber.step__chamber_ramp,
name='CHAMBER RAMP {0}'.format(temperature),
kwargs={'action': temperature})
corner_seq_sublevel1 = corner_seq.add_sequence('UUT-MONITOR GROUP',
parallel_steps=True)
corner_seq_sublevel1.add_step(
steps_ess_chamber.step__chamber_start_monitor,
name="CHAMBER MONITOR START {0}".format(i))
corner_seq_sublevel2 = corner_seq_sublevel1.add_sequence(
'UUT AT {0} VOLT'.format(voltage))
corner_seq_sublevel3 = corner_seq_sublevel2.add_sequence(
'UUT TESTS',
adt_enabled=adt_flag,
jump_on_error="CHAMBER MONITOR STOP {0}".format(i))
corner_seq_sublevel3.add_step(steps_nyquist.power_cycle_on,
name='POWER ON BOOT',
group_level=5)
if True: # Logic branch for chamber debug (if needed)
corner_seq_sublevel3.add_step(steps_nyquist.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
corner_seq_sublevel3.add_step(
steps_nyquist.diags_switch_mcu_mode,
name='MCU MODE IOS',
kwargs={'kkmode': 'IOS'})
corner_seq_sublevel3.add_step(steps_nyquist.diags_sysinit,
name='DIAG SYSINIT')
corner_seq_sublevel3.add_step(steps_nyquist.diags_vmargin_test,
name='VOLTAGE MARGIN',
kwargs={
'device_instance': 0,
'margin_level': voltage
})
corner_seq_sublevel3.add_step(
steps_nyquist.diags_temperature_test,
name='UUT TEMPERATURES',
kwargs={
'temperature_corner': temperature,
'operational_state': 'idle'
})
corner_seq_sublevel3.add_step(steps_nyquist.diags_psu_check,
name='PSU CHECK',
kwargs={})
corner_seq_sublevel3.add_step(
steps_nyquist.diags_stackrac_test,
name='STACKRAC TEST',
kwargs={})
corner_seq_sublevel3.add_step(
steps_nyquist.diags_serdeseye_sif_test,
name='SERDES EYE SIF TEST',
kwargs={})
corner_seq_sublevel3.add_step(
steps_nyquist.diags_serdeseye_nif_test,
name='SERDES EYE NIF TEST',
kwargs={})
# Diag Testlist build-out
corner_seq_sublevel3_diag = corner_seq_sublevel3.add_sequence(
'DIAG TESTS')
corner_seq_sublevel3_diag.add_step(steps_nyquist.goto_mode,
name='MODE DIAG',
kwargs={'mode': 'DIAG'})
dynamic_sequence_builder.build_diag_testlist_subseq(
diag_seq=corner_seq_sublevel3_diag,
container=container,
udd=udd,
step_module=steps_nyquist,
category=None,
enabled=True)
# Traffic Testlist build-out
corner_seq_sublevel3_traf = corner_seq_sublevel3.add_sequence(
'TRAF TESTS')
corner_seq_sublevel3_traf.add_step(steps_nyquist.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
dynamic_sequence_builder.build_traffic_cases_subseq(
traffic_seq=corner_seq_sublevel3_traf,
container=container,
udd=udd,
step_module=steps_nyquist,
category=None,
enabled=True)
# Corner wrap-up
corner_seq_sublevel2.add_step(
steps_ess_chamber.step__chamber_stop_monitor,
name="CHAMBER MONITOR STOP {0}".format(i),
kwargs={},
group_level=aplib.FINALIZATION - 2)
corner_seq.add_step(steps_nyquist.power_off,
name='POWER OFF',
group_level=aplib.FINALIZATION - 1)
# ------------------------------------------------------------------------------------------------------------------
# Chamber Wrap-Up
# 1. Chamber Stop will sync all containers AND return chamber to ambient.
# 2. Power off each UUT.
# 3. Clean Up (remove classes and clean userdict)
final_seq = seq.add_sequence('FINAL', finalization=True)
final_seq.add_step(steps_ess_chamber.step__chamber_final,
name="CHAMBER STOP",
kwargs={},
group_level=aplib.FINALIZATION - 3)
final_seq.add_step(steps_nyquist.power_off,
name='POWER OFF',
group_level=aplib.FINALIZATION - 2)
final_seq.add_step(steps_nyquist.clean_up,
name='CLEAN UP',
group_level=aplib.FINALIZATION - 1)
return seq
def prestep__chamber_post_staging():
ACTIVECS_KEY, _ = get_chamber_slots_keys()
active_chamber_slots = aplib.get_cached_data(ACTIVECS_KEY)
log.debug("Active chamber slots: {0}".format(active_chamber_slots))
return aplib.PASS
def standard_switch_sequence_definition():
try:
container = aplib.get_my_container_key()
except Exception:
raise Exception("Cannot use this Apollo version!")
udd = aplib.get_cached_data('{0}_uut_descriptor'.format(container))
pf = udd.get('product_family').upper()
pc = udd.get('product_codename').upper()
psd = udd.get('uut_config', {}).get('prod_seq_def', {})
area = __area__ # udd.get('test_area', None)
seq = aplib.get_sequence_definition('{0} {1} {2} {3} SEQ'.format(
__product_line__, pf, pc, area),
jump_on_error='FINAL')
# ------------------------------------------------------------------------------------------------------------------
# Init
init_seq = seq.add_sequence('INITIALIZATION')
init_seq.add_step(steps_nyquist.init, name='INIT', kwargs={})
init_seq.add_step(steps_nyquist.ud_retrieve,
name="RETRIEVE UUT DESCRIPTOR")
init_seq.add_step(steps_nyquist.ud_print_uut_descriptor,
name='PRINT DESCRIPTOR')
init_seq.add_step(steps_nyquist.ud_print_uut_config,
name='PRINT UUT CONFIG')
# Area Check
seq.add_step(steps_nyquist.process_area_check,
name='AREACHECK',
kwargs={},
enabled=True)
# Power ON & Boot
# Unit should already be powered up from pre-sequence auto-discovery.
# seq.add_step(steps_nyquist.power_cycle_on, name='POWER ON BOOT', group_level=5, enabled=False)
# Basic Mode
seq.add_step(steps_nyquist.goto_mode,
name='MODE BTLDR',
kwargs={'mode': 'BTLDR'})
# ------------------------------------------------------------------------------------------------------------------
# PCAMAP
pcamap_seq = seq.add_sequence('PCAMAP PROGRAMMING', enabled=True)
# Verify CMPD
# TODO: waiting Trac #5852
pcamap_seq.add_step(steps_nyquist.process_verify_cmpd,
name='VERIFY CMPD SPROM',
enabled=False,
kwargs={
'force': False,
'cmpd_description': 'SPROM',
'uut_type_key': 'MODEL_NUM',
'part_number_key': 'TAN_NUM',
'part_revision_key': 'TAN_REVISION_NUMBER',
'eco_type': 'VERIFICATION'
})
# PCAMAP Program
pcamap_seq.add_step(steps_nyquist.pcamap_write_uut,
name='PCAMAP PROGRAM',
kwargs={
'device_instance': 0,
'memory_type': 'vb'
})
# PIDVID Verify
seq.add_step(steps_nyquist.process_verify_pidvid,
name='PIDVID VERIFY',
jump_on_error='CLEAN UP')
# ------------------------------------------------------------------------------------------------------------------
# Diag Testing
diag_seq = seq.add_sequence('DIAGNOSTIC TESTS', enabled=True)
diag_seq.add_step(steps_nyquist.goto_mode,
name='MODE STARDUST',
kwargs={'mode': 'STARDUST'})
diag_seq.add_step(steps_nyquist.diags_sysinit, name='SYSINIT')
diag_seq.add_step(steps_nyquist.diags_psu_check,
name='PSU CHECK',
kwargs={})
# Diag Testlist build-out
dynamic_sequence_builder.build_diag_testlist_subseq(
diag_seq=diag_seq,
container=container,
udd=udd,
step_module=steps_nyquist,
category=None,
enabled=True)
# ------------------------------------------------------------------------------------------------------------------
# Traffic Testing
traf_seq = seq.add_sequence('TRAFFIC TESTS', enabled=True)
traf_seq.add_step(steps_nyquist.goto_mode,
name='MODE STARDUST PRETRAF',
kwargs={'mode': 'STARDUST'})
traf_seq.add_step(steps_nyquist.diags_sysinit, name='DIAG SYSINIT PRETRAF')
dynamic_sequence_builder.build_traffic_cases_subseq(
traffic_seq=traf_seq,
container=container,
udd=udd,
step_module=steps_nyquist,
category=None,
enabled=True)
# ------------------------------------------------------------------------------------------------------------------
# Power OFF
seq.add_step(steps_nyquist.power_off, name='POWER OFF', group_level=1000)
# Clean up
final_seq = seq.add_sequence('FINAL', finalization=True)
final_seq.add_step(steps_nyquist.power_off,
name='POWER OFF',
kwargs={},
group_level=1000)
final_seq.add_step(steps_nyquist.clean_up, name='CLEAN UP')
final_seq.add_step(steps_nyquist.final, name='END')
return seq
def set_global_corners(forced_corners=None):
""" Set Global ChamberCorners
Used by the UUT Container PRE-SEQ.
This sets the corners to be used by ALL UUTs in the chamber via a global data cache.
IMPORTANT: Global cache key is the station path (i.e. chamber).
Differing product families are allowed to run but their corner selections MUST match; if not then it will abort.
Example set in product_definition:
'chamber_corners': [('NTNV', False), ('HTLV', True), ('HTHV', True), ('LTLV', True)]
Example of globally saved after processing:
OrderedDict([('NTNV', ('AMBIENT', 'NOMINAL', False)),
('HTLV', ('HOT', 'LOW', True)),
('HTHV', ('HOT', 'HIGH', True)),
('LTLV', ('COLD', 'LOW', True))])
:param (list) forced_corners:
:return:
"""
log.debug("Global Corners: set...")
# Check for a product-specific corner definition.
_lookup = {
'HT': HOT,
'LT': COLD,
'NT': AMBIENT,
'HV': 'HIGH',
'LV': 'LOW',
'NV': 'NOMINAL'
}
container = aplib.get_my_container_key()
try:
udd = aplib.apdicts.userdict.get('udd')
if not udd:
log.error("The UutDescriptor Dict was not available.")
log.error(
"Please confirm proper application of the application software!"
)
raise Exception("The UutDescriptor Dict was not available.")
chamber_corners = udd.get('chamber_corners')
if forced_corners:
listed_corners = collections.OrderedDict(forced_corners)
log.debug("Chamber Corners Source: FORCED.")
elif chamber_corners:
listed_corners = collections.OrderedDict(chamber_corners)
log.debug("Chamber Corners Source: UUT DESCRIPTOR.")
else:
log.warning(
"No UutDescriptor chamber_corners, or forced_corners available."
)
log.warning(
"Check the product definitions and common definition for 'chamber_corners'."
)
log.warning(
"The default '2-Corner' sequence (HTLV, LTHV) will be used.")
listed_corners = [('LTHV', True), ('HTLV', True)]
processed_corners = []
if listed_corners:
for lc in listed_corners:
name = lc[0] if isinstance(lc, tuple) else lc
adt = lc[1] if isinstance(lc, tuple) and len(lc) > 1 else False
if len(name) == 4:
temp = _lookup.get(name[:2], AMBIENT)
volt = _lookup.get(name[2:4], 'NOMINAL')
elif len(name) == 2:
temp = _lookup.get(name, AMBIENT)
volt = 'NOMINAL'
else:
temp = AMBIENT
volt = 'NOMINAL'
processed_corners.append((name, (temp, volt, adt)))
corners = collections.OrderedDict(
processed_corners) if processed_corners else None
except (KeyError, AttributeError):
log.warning(
"Chamber corner data is not available or not in correct form.")
return False
log.debug('-' * 20)
log.debug("{0} : Chamber Corners = {1}".format(container, listed_corners))
# Now check for proper form of corners dict.
for corner in corners:
if not isinstance(corners[corner], tuple):
log.error("Product specific corners are not in the proper form.")
raise apexceptions.AbortException
# Get the current corner definition (possibly set by another container in the same chamber)
S_KEY = '_'.join(container.split('|')[:-1])
cc_key = 'chamber_corners_' + S_KEY
with locking.named_priority_lock('__corners__' + S_KEY):
try:
log.debug("Chamber corner cache key (set) = {0}".format(cc_key))
established_corners = aplib.get_cached_data(cc_key)
except (KeyError, apexceptions.ApolloException):
established_corners = None
if not forced_corners:
# Save the product-specific corner selections for use by SEQ.
if not established_corners:
established_corners = corners
aplib.cache_data(cc_key, established_corners)
log.debug(
"*** A new chamber corner set has been established. ***")
# All UUT corner definitions must match. This allows different PIDs in the same chamber BUT requires them
# to all have the same corner definition.
if corners != established_corners:
log.error("Chamber corners: REJECTED!")
log.error(
"There is a mismatch of chamber_corners in {0}. This is NOT allowed."
.format(container))
log.error(
"Please correct the situation before running the chamber. Inspect UUT product definitions."
)
raise apexceptions.AbortException(
"MISMATCH of chamber corners in {0}.".format(container))
else:
log.debug("Chamber corners: ACCEPTED. {0}".format(
established_corners))
else:
aplib.cache_data(cc_key, corners)
log.debug("Chamber corners: FORCED. {0}".format(corners))
return True
