def validate_parms(): r""" Validate all program parameters. """ process_pgm_parms() gp.qprintn() global openbmc_model if openbmc_model == "": status, ret_values =\ grk.run_key_u("Get BMC System Model") openbmc_model = ret_values BuiltIn().set_global_variable("${openbmc_model}", openbmc_model) gv.set_exit_on_error(True) gv.valid_value(openbmc_host) gv.valid_value(openbmc_username) gv.valid_value(openbmc_password) gv.valid_value(rest_username) gv.valid_value(rest_password) gv.valid_value(ipmi_username) gv.valid_value(ipmi_password) if os_host != "": gv.valid_value(os_username) gv.valid_value(os_password) if pdu_host != "": gv.valid_value(pdu_username) gv.valid_value(pdu_password) gv.valid_integer(pdu_slot_no) if openbmc_serial_host != "": gv.valid_integer(openbmc_serial_port) gv.valid_value(openbmc_model) gv.valid_integer(max_num_tests) gv.valid_integer(boot_pass) gv.valid_integer(boot_fail) plug_in_packages_list = grpi.rvalidate_plug_ins(plug_in_dir_paths) BuiltIn().set_global_variable("${plug_in_packages_list}", plug_in_packages_list) gv.valid_value(stack_mode, valid_values=['normal', 'skip']) gv.set_exit_on_error(False) if len(boot_list) == 0 and len(boot_stack) == 0 and not ffdc_only: error_message = "You must provide either a value for either the" +\ " boot_list or the boot_stack parm.\n" BuiltIn().fail(gp.sprint_error(error_message)) valid_boot_list(boot_list, valid_boot_types) valid_boot_list(boot_stack, valid_boot_types) selected_PDU_boots = list( set(boot_list + boot_stack) & set(boot_lists['PDU_reboot'])) if len(selected_PDU_boots) > 0 and pdu_host == "": error_message = "You have selected the following boots which" +\ " require a PDU host but no value for pdu_host:\n" error_message += gp.sprint_var(selected_PDU_boots) error_message += gp.sprint_var(pdu_host, fmt=gp.blank()) BuiltIn().fail(gp.sprint_error(error_message)) return
def wait_for_comm_cycle(start_boot_seconds, quiet=None): r""" Wait for the BMC uptime to be less than elapsed_boot_time. This function will tolerate an expected loss of communication to the BMC. This function is useful when some kind of reboot has been initiated by the caller. Description of argument(s): start_boot_seconds The time that the boot test started. The format is the epoch time in seconds, i.e. the number of seconds since 1970-01-01 00:00:00 UTC. This value should be obtained from the BMC so that it is not dependent on any kind of synchronization between this machine and the target BMC This will allow this program to work correctly even in a simulated environment. This value should be obtained by the caller prior to initiating a reboot. It can be obtained as follows: state = st.get_state(req_states=['epoch_seconds']) """ quiet = int(gp.get_var_value(quiet, 0)) # Validate parms. error_message = gv.valid_integer(start_boot_seconds) if error_message: BuiltIn().fail(gp.sprint_error(error_message)) # Wait for uptime to be less than elapsed_boot_time. set_start_boot_seconds(start_boot_seconds) expr = 'int(float(state[\'uptime\'])) < int(state[\'elapsed_boot_time\'])' match_state = DotDict([('uptime', '^[0-9\\.]+$'), ('elapsed_boot_time', '^[0-9]+$'), (expressions_key(), [expr])]) wait_state(match_state, wait_time="12 mins", interval="5 seconds") gp.qprint_timen("Verifying that REST/Redfish API interface is working.") if not redfish_support_trans_state: match_state = DotDict([('rest', '^1$')]) else: match_state = DotDict([('redfish', '^1$')]) state = wait_state(match_state, wait_time="5 mins", interval="2 seconds")
def valid_integer(var_name, *args, **kwargs): var_value, args, kwargs = valid_init(var_name, *args, **kwargs) error_message = \ gv.valid_integer(var_value, *args, var_name=var_name, **kwargs) process_error_message(error_message)
def wait_for_comm_cycle(start_boot_seconds, quiet=None): r""" Wait for communications to the BMC to stop working and then resume working. This function is useful when you have initiated some kind of reboot. Description of arguments: start_boot_seconds The time that the boot test started. The format is the epoch time in seconds, i.e. the number of seconds since 1970-01-01 00:00:00 UTC. This value should be obtained from the BMC so that it is not dependent on any kind of synchronization between this machine and the target BMC This will allow this program to work correctly even in a simulated environment. This value should be obtained by the caller prior to initiating a reboot. It can be obtained as follows: state = st.get_state(req_states=['epoch_seconds']) """ quiet = int(gp.get_var_value(quiet, 0)) # Validate parms. error_message = gv.valid_integer(start_boot_seconds, var_name="start_boot_seconds") if error_message != "": BuiltIn().fail(gp.sprint_error(error_message)) match_state = anchor_state(DotDict([('packet_loss', '100')])) # Wait for 100% packet loss trying to ping machine. wait_state(match_state, wait_time="8 mins", interval="0 seconds") match_state['packet_loss'] = '^0$' # Wait for 0% packet loss trying to ping machine. wait_state(match_state, wait_time="8 mins", interval="0 seconds") # Get the uptime and epoch seconds for comparisons. We want to be sure # that the uptime is less than the elapsed boot time. Further proof that # a reboot has indeed occurred (vs random network instability giving a # false positive. We also use wait_state because the BMC may take a short # while to be ready to process SSH requests. match_state = DotDict([('uptime', '^[0-9\\.]+$'), ('epoch_seconds', '^[0-9]+$')]) state = wait_state(match_state, wait_time="2 mins", interval="1 second") elapsed_boot_time = int(state['epoch_seconds']) - start_boot_seconds gp.qprint_var(elapsed_boot_time) if state['uptime'] == "": error_message = "Unable to obtain uptime from the BMC. BMC is not" +\ " communicating." BuiltIn().fail(gp.sprint_error(error_message)) if int(float(state['uptime'])) < elapsed_boot_time: uptime = state['uptime'] gp.qprint_var(uptime) gp.qprint_timen("The uptime is less than the elapsed boot time," + " as expected.") else: error_message = "The uptime is greater than the elapsed boot time," +\ " which is unexpected:\n" +\ gp.sprint_var(start_boot_seconds) +\ gp.sprint_var(state) BuiltIn().fail(gp.sprint_error(error_message)) gp.qprint_timen("Verifying that REST API interface is working.") match_state = DotDict([('rest', '^1$')]) state = wait_state(match_state, wait_time="5 mins", interval="2 seconds")