def restore_plug_in_value(*args, **kwargs): r""" Return a value from a plug-in save file. The args/kwargs are interpreted differently depending on how this function is called. Mode 1 - The output of this function is assigned to a variable: Example: my_var1 = restore_plug_in_value(2) In this mode, the lvalue ("my_var1" in this example) will serve as the name of the value to be restored. Mode 2 - The output of this function is NOT assigned to a variable: Example: if restore_plug_in_value('my_var1', 2): do_something() In this mode, the caller must explicitly provide the name of the value being restored. The args/kwargs are interpreted as follows: Description of argument(s): var_name The name of the value to be restored. Only relevant in mode 1 (see example above). default The default value to be returned if there is no plug-in save file for the value in question. plug_in_package_name See compose_plug_in_save_dir_path for details. """ # Process args. lvalue = gp.get_arg_name(0, -1, stack_frame_ix=2) if lvalue: var_name = lvalue else: var_name, args, kwargs = fa.pop_arg("", *args, **kwargs) default, args, kwargs = fa.pop_arg("", *args, **kwargs) plug_in_package_name, args, kwargs = fa.pop_arg(None, *args, **kwargs) if args or kwargs: error_message = "Programmer error - Too many arguments passed for this function." raise ValueError(error_message) plug_in_save_dir_path = create_plug_in_save_dir(plug_in_package_name) save_file_path = plug_in_save_dir_path + var_name if os.path.isfile(save_file_path): gp.qprint_timen("Restoring " + var_name + " value from " + save_file_path + ".") var_value = gm.file_to_list(save_file_path, newlines=0, comments=0, trim=1)[0] if type(default) is bool: # Convert from string to bool. var_value = (var_value == 'True') if type(default) is int: # Convert from string to int. var_value = int(var_value) else: var_value = default gp.qprint_timen("Save file " + save_file_path + " does not exist so returning default value.") gp.qprint_varx(var_name, var_value) return var_value
def restore_plug_in_value(default="", plug_in_package_name=None): r""" Return a value from a plug-in save file. The name of the value to be restored will be determined by this function based on the lvalue being assigned. Consider the following example: my_var1 = restore_plug_in_value(2) In this example, this function would look for the "my_var1" file in the plug-in save directory, read its value and return it. If no such file exists, the default value of 2 would be returned. Description of argument(s): default The default value to be returned if there is no plug-in save file for the value in question. plug_in_package_name See compose_plug_in_save_dir_path for details. """ # Get the lvalue from the caller's invocation of this function. lvalue = gp.get_arg_name(0, -1, stack_frame_ix=2) plug_in_save_dir_path = create_plug_in_save_dir(plug_in_package_name) save_file_path = plug_in_save_dir_path + lvalue if os.path.isfile(save_file_path): gp.qprint_timen("Restoring " + lvalue + " value from " + save_file_path + ".") value = gm.file_to_list(save_file_path, newlines=0, comments=0, trim=1)[0] if type(default) is bool: # Convert from string to bool. value = (value == 'True') if type(default) is int: # Convert from string to int. value = int(value) gp.qprint_varx(lvalue, value) return value else: gp.qprint_timen("Save file " + save_file_path + " does not exist so returning default value.") gp.qprint_var(default) return default
def save_plug_in_value(var_value=None, plug_in_package_name=None, **kwargs): r""" Save a value in a plug-in save file. The value may be retrieved later via a call to the restore_plug_in_value function. This function will figure out the variable name corresponding to the value passed and use that name in creating the plug-in save file. The caller may pass the value as a simple variable or as a keyword=value (see examples below). Example 1: my_var1 = 5 save_plug_in_value(my_var1) In this example, the value "5" would be saved to the "my_var1" file in the plug-in save directory. Example 2: save_plug_in_value(my_var1=5) In this example, the value "5" would be saved to the "my_var1" file in the plug-in save directory. Description of argument(s): var_value The value to be saved. plug_in_package_name See compose_plug_in_save_dir_path for details. kwargs The first entry may contain a var_name/var_value. Other entries are ignored. """ if var_value is None: var_name = next(iter(kwargs)) var_value = kwargs[var_name] else: # Get the name of the variable used as argument one to this function. var_name = gp.get_arg_name(0, 1, stack_frame_ix=2) plug_in_save_dir_path = create_plug_in_save_dir(plug_in_package_name) save_file_path = plug_in_save_dir_path + var_name gp.qprint_timen("Saving \"" + var_name + "\" value.") gp.qprint_varx(var_name, var_value) gc.shell_cmd("echo '" + str(var_value) + "' > " + save_file_path)
def select_boot(): r""" Select a boot test to be run based on our current state and return the chosen boot type. Description of arguments: state The state of the machine. """ global boot_stack gp.qprint_timen("Selecting a boot test.") my_get_state() stack_popped = 0 if len(boot_stack) > 0: stack_popped = 1 gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() skip_boot_printed = 0 while len(boot_stack) > 0: boot_candidate = boot_stack.pop() if stack_mode == 'normal': break else: if st.compare_states(state, boot_table[boot_candidate]['end']): if not skip_boot_printed: gp.qprint_var(stack_mode) gp.qprintn() gp.qprint_timen("Skipping the following boot tests" + " which are unnecessary since their" + " required end states match the" + " current machine state:") skip_boot_printed = 1 gp.qprint_var(boot_candidate) boot_candidate = "" if boot_candidate == "": gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() return boot_candidate if st.compare_states(state, boot_table[boot_candidate]['start']): gp.qprint_timen("The machine state is valid for a '" + boot_candidate + "' boot test.") gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() return boot_candidate else: gp.qprint_timen("The machine state does not match the required" + " starting state for a '" + boot_candidate + "' boot test:") gp.qprint_varx("boot_table[" + boot_candidate + "][start]", boot_table[boot_candidate]['start'], 1) boot_stack.append(boot_candidate) popped_boot = boot_candidate # Loop through your list selecting a boot_candidates boot_candidates = [] for boot_candidate in boot_list: if st.compare_states(state, boot_table[boot_candidate]['start']): if stack_popped: if st.compare_states(boot_table[boot_candidate]['end'], boot_table[popped_boot]['start']): boot_candidates.append(boot_candidate) else: boot_candidates.append(boot_candidate) if len(boot_candidates) == 0: gp.qprint_timen("The user's boot list contained no boot tests" + " which are valid for the current machine state.") boot_candidate = default_power_on if not st.compare_states(state, boot_table[default_power_on]['start']): boot_candidate = default_power_off boot_candidates.append(boot_candidate) gp.qprint_timen("Using default '" + boot_candidate + "' boot type to transition to valid state.") gp.dprint_var(boot_candidates) # Randomly select a boot from the candidate list. boot = random.choice(boot_candidates) return boot
def select_boot(): r""" Select a boot test to be run based on our current state and return the chosen boot type. Description of arguments: state The state of the machine. """ global transitional_boot_selected global boot_stack gp.qprint_timen("Selecting a boot test.") if transitional_boot_selected and not boot_success: prior_boot = next_boot boot_candidate = boot_stack.pop() gp.qprint_timen("The prior '" + next_boot + "' was chosen to" + " transition to a valid state for '" + boot_candidate + "' which was at the top of the boot_stack. Since" + " the '" + next_boot + "' failed, the '" + boot_candidate + "' has been removed from the stack" + " to avoid and endless failure loop.") if len(boot_stack) == 0: return "" my_get_state() valid_state() transitional_boot_selected = False stack_popped = 0 if len(boot_stack) > 0: stack_popped = 1 gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() skip_boot_printed = 0 while len(boot_stack) > 0: boot_candidate = boot_stack.pop() if stack_mode == 'normal': break else: if st.compare_states(state, boot_table[boot_candidate]['end']): if not skip_boot_printed: gp.qprint_var(stack_mode) gp.qprintn() gp.qprint_timen("Skipping the following boot tests" + " which are unnecessary since their" + " required end states match the" + " current machine state:") skip_boot_printed = 1 gp.qprint_var(boot_candidate) boot_candidate = "" if boot_candidate == "": gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() return boot_candidate if st.compare_states(state, boot_table[boot_candidate]['start']): gp.qprint_timen("The machine state is valid for a '" + boot_candidate + "' boot test.") gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() return boot_candidate else: gp.qprint_timen("The machine state does not match the required" + " starting state for a '" + boot_candidate + "' boot test:") gp.qprint_varx("boot_table_start_entry", boot_table[boot_candidate]['start']) boot_stack.append(boot_candidate) transitional_boot_selected = True popped_boot = boot_candidate # Loop through your list selecting a boot_candidates boot_candidates = [] for boot_candidate in boot_list: if st.compare_states(state, boot_table[boot_candidate]['start']): if stack_popped: if st.compare_states(boot_table[boot_candidate]['end'], boot_table[popped_boot]['start']): boot_candidates.append(boot_candidate) else: boot_candidates.append(boot_candidate) if len(boot_candidates) == 0: gp.qprint_timen("The user's boot list contained no boot tests" + " which are valid for the current machine state.") boot_candidate = default_power_on if not st.compare_states(state, boot_table[default_power_on]['start']): boot_candidate = default_power_off boot_candidates.append(boot_candidate) gp.qprint_timen("Using default '" + boot_candidate + "' boot type to transition to valid state.") gp.dprint_var(boot_candidates) # Randomly select a boot from the candidate list. boot = random.choice(boot_candidates) return boot
def build_ipmi_ext_cmd(quiet=None): r""" Build the global IPMI_EXT_CMD variable. If global variable IPMI_EXT_CMD already has a value, this keyword will simply return without taking any action. This keyword is designed for use by keywords which use the IPMI_EXT_CMD variable (e.g. 'Run External IPMI Raw Command'). This keyword is warranted because the ipmitool program may or may not accept the -U (i.e. username) parameter depending on the version of code loaded on the BMC. This keyword will determine whether the "-U" parameter should be used and create IPMI_EXT_CMD accordingly. Furthermore, this keyword will run the command to create the 'root' IPMI username. Description of argument(s): # quiet Indicates whether this keyword should run # without any output to the console. """ ipmi_ext_cmd = BuiltIn().get_variable_value("${IPMI_EXT_CMD}", "") if ipmi_ext_cmd != "": return quiet = int(gp.get_var_value(quiet, 0)) openbmc_host = BuiltIn().get_variable_value("${OPENBMC_HOST}") ipmi_username = BuiltIn().get_variable_value("${IPMI_USERNAME}", "root") ipmi_password = BuiltIn().get_variable_value("${IPMI_PASSWORD}", "0penBmc") ipmi_cipher_level = BuiltIn().get_variable_value("${IPMI_CIPHER_LEVEL}", "3") old_ipmi_ext_cmd = "ipmitool -I lanplus -C " + str(ipmi_cipher_level)\ + " -P " + ipmi_password new_ipmi_ext_cmd = "ipmitool -I lanplus -C " + str(ipmi_cipher_level)\ + " -U " + ipmi_username + " -P " + ipmi_password # Use a basic ipmitool command to help us determine whether the BMC will # accept the -U parm. ipmi_cmd = "power status" ipmi_cmd_suffix = " -H " + openbmc_host + " " + ipmi_cmd print_output = 0 cmd_buf = new_ipmi_ext_cmd + ipmi_cmd_suffix new_rc, stdout = gc.shell_cmd(cmd_buf, print_output=print_output, show_err=0, ignore_err=1) gp.qprint_varx("rc", new_rc, 1) if new_rc == 0: ipmi_ext_cmd = new_ipmi_ext_cmd BuiltIn().set_global_variable("${IPMI_EXT_CMD}", ipmi_ext_cmd) return cmd_buf = old_ipmi_ext_cmd + ipmi_cmd_suffix old_rc, stdout = gc.shell_cmd(cmd_buf, print_output=print_output, show_err=0, ignore_err=1) gp.qprint_varx("rc", old_rc, 1) if old_rc == 0: ipmi_ext_cmd = old_ipmi_ext_cmd BuiltIn().set_global_variable("${IPMI_EXT_CMD}", ipmi_ext_cmd) return message = "Unable to run ipmitool, (with or without the '-U' parm)." BuiltIn().fail(message)
def select_boot(): r""" Select a boot test to be run based on our current state and return the chosen boot type. Description of arguments: state The state of the machine. """ global transitional_boot_selected global boot_stack gp.qprint_timen("Selecting a boot test.") if transitional_boot_selected and not boot_success: prior_boot = next_boot boot_candidate = boot_stack.pop() gp.qprint_timen("The prior '" + next_boot + "' was chosen to" + " transition to a valid state for '" + boot_candidate + "' which was at the top of the boot_stack. Since" + " the '" + next_boot + "' failed, the '" + boot_candidate + "' has been removed from the stack" + " to avoid and endless failure loop.") if len(boot_stack) == 0: return "" my_get_state() valid_state() transitional_boot_selected = False stack_popped = 0 if len(boot_stack) > 0: stack_popped = 1 gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() skip_boot_printed = 0 while len(boot_stack) > 0: boot_candidate = boot_stack.pop() if stack_mode == 'normal': break else: if st.compare_states(state, boot_table[boot_candidate]['end']): if not skip_boot_printed: gp.qprint_var(stack_mode) gp.qprintn() gp.qprint_timen("Skipping the following boot tests" + " which are unnecessary since their" + " required end states match the" + " current machine state:") skip_boot_printed = 1 gp.qprint_var(boot_candidate) boot_candidate = "" if boot_candidate == "": gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() return boot_candidate if st.compare_states(state, boot_table[boot_candidate]['start']): gp.qprint_timen("The machine state is valid for a '" + boot_candidate + "' boot test.") gp.qprint_dashes() gp.qprint_var(boot_stack) gp.qprint_dashes() return boot_candidate else: gp.qprint_timen("The machine state does not match the required" + " starting state for a '" + boot_candidate + "' boot test:") gp.qprint_varx("boot_table[" + boot_candidate + "][start]", boot_table[boot_candidate]['start'], 1) boot_stack.append(boot_candidate) transitional_boot_selected = True popped_boot = boot_candidate # Loop through your list selecting a boot_candidates boot_candidates = [] for boot_candidate in boot_list: if st.compare_states(state, boot_table[boot_candidate]['start']): if stack_popped: if st.compare_states(boot_table[boot_candidate]['end'], boot_table[popped_boot]['start']): boot_candidates.append(boot_candidate) else: boot_candidates.append(boot_candidate) if len(boot_candidates) == 0: gp.qprint_timen("The user's boot list contained no boot tests" + " which are valid for the current machine state.") boot_candidate = default_power_on if not st.compare_states(state, boot_table[default_power_on]['start']): boot_candidate = default_power_off boot_candidates.append(boot_candidate) gp.qprint_timen("Using default '" + boot_candidate + "' boot type to transition to valid state.") gp.dprint_var(boot_candidates) # Randomly select a boot from the candidate list. boot = random.choice(boot_candidates) return boot