def exit_not_master(): r""" Exit the program with return code zero if this program was NOT called by the master program. There are cases where plug-ins are called by a multi-layered stack: master_wrapper obmc_boot_test.py Example_plug_in/cp_setup In a scenario like this, Example_plug_in/cp_setup may be called once directly by master_wrapper (the master) and and then called again directly by obmc_boot_test.py (the child). Some plug-in programs may wish to avoid doing any processing on the second such call. This function will achieve that purpose. This function will print a standard message to stdout prior to exiting. """ AUTOBOOT_MASTER_PID = gm.get_mod_global("AUTOBOOT_MASTER_PID") AUTOBOOT_PROGRAM_PID = gm.get_mod_global("AUTOBOOT_PROGRAM_PID") if AUTOBOOT_MASTER_PID != AUTOBOOT_PROGRAM_PID: message = get_plug_in_package_name() + "/" + gp.pgm_name + " is not" \ + " being called by the master program in the stack so no action" \ + " will be taken." gp.qprint_timen(message) gp.qprint_vars(AUTOBOOT_MASTER_PID, AUTOBOOT_PROGRAM_PID) exit(0)
def compose_plug_in_save_dir_path(plug_in_package_name=None): r""" Create and return a directory path name that is suitable for saving plug-in data. The name will be comprised of things such as plug_in package name, pid, etc. in order to guarantee that it is unique for a given test run. Description of argument(s): plug_in_package_name The plug-in package name. This defaults to the name of the caller's plug-in package. However, the caller can specify another value in order to retrieve data saved by another plug-in package. """ plug_in_package_name = gm.dft(plug_in_package_name, get_plug_in_package_name()) BASE_TOOL_DIR_PATH = \ gm.add_trailing_slash(os.environ.get(PLUG_VAR_PREFIX + "_BASE_TOOL_DIR_PATH", "/tmp/")) NICKNAME = os.environ.get("AUTOBOOT_OPENBMC_NICKNAME", "") if NICKNAME == "": NICKNAME = os.environ["AUTOIPL_FSP1_NICKNAME"] MASTER_PID = os.environ[PLUG_VAR_PREFIX + "_MASTER_PID"] gp.qprint_vars(BASE_TOOL_DIR_PATH, NICKNAME, plug_in_package_name, MASTER_PID) return BASE_TOOL_DIR_PATH + gm.username() + "/" + NICKNAME + "/" +\ plug_in_package_name + "/" + str(MASTER_PID) + "/"
def check_state_files(files): err_msgs = [] passed = "PASS" check_cmd = "Check Fail In State File" for state_file in files: cmd_buf = [check_cmd, state_file] status, error = BuiltIn().run_keyword_and_ignore_error(*cmd_buf) gp.qprint_vars(status, error) if status != "PASS": passed = status err_msgs.append(state_file + ", " + error) return passed, ", ".join(err_msgs)
def process_robot_output_files(robot_cmd_buf=None, robot_rc=None, gzip=1): r""" Process robot output files which can involve several operations: - If the files are in a temporary location, using SAVE_STATUS_POLICY to decide whether to move them to a permanent location or to delete them. - Gzipping them. Description of argument(s): robot_cmd_buf The complete command string used to invoke robot. robot_rc The return code from running the robot command string. gzip Indicates whether robot-generated output should be gzipped. """ robot_cmd_buf = gm.dft(robot_cmd_buf, gcr_last_robot_cmd_buf) robot_rc = gm.dft(robot_rc, gcr_last_robot_rc) if robot_cmd_buf == "": # This can legitimately occur if this function is called from an # exit_function without the program having ever run robot_cmd_fnc. return SAVE_STATUS_POLICY = os.environ.get("SAVE_STATUS_POLICY", "ALWAYS") gp.qprint_vars(SAVE_STATUS_POLICY) # When SAVE_STATUS_POLICY is "NEVER" robot output files don't even get # generated. if SAVE_STATUS_POLICY == "NEVER": return # Compose file_list based on robot command buffer passed in. robot_cmd_buf_dict = gc.parse_command_string(robot_cmd_buf) outputdir = robot_cmd_buf_dict['outputdir'] outputdir = gm.add_trailing_slash(outputdir) file_list = outputdir + robot_cmd_buf_dict['output'] + " " + outputdir\ + robot_cmd_buf_dict['log'] + " " + outputdir\ + robot_cmd_buf_dict['report'] # Double checking that files are present. shell_rc, out_buf = gc.shell_cmd("ls -1 " + file_list + " 2>/dev/null", show_err=0) file_list = re.sub("\n", " ", out_buf.rstrip("\n")) if file_list == "": gp.qprint_timen("No robot output files were found in " + outputdir + ".") return gp.qprint_var(robot_rc, 1) if SAVE_STATUS_POLICY == "FAIL" and robot_rc == 0: gp.qprint_timen("The call to robot produced no failures." + " Deleting robot output files.") gc.shell_cmd("rm -rf " + file_list) return if gzip: gc.shell_cmd("gzip " + file_list) # Update the values in file_list. file_list = re.sub(" ", ".gz ", file_list) + ".gz" # It TMP_ROBOT_DIR_PATH is set, it means the caller wanted the robot # output initially directed to TMP_ROBOT_DIR_PATH but later moved to # FFDC_DIR_PATH. Otherwise, we're done. if os.environ.get("TMP_ROBOT_DIR_PATH", "") is "": return # We're directing these to the FFDC dir path so that they'll be subjected # to FFDC cleanup. target_dir_path = os.environ.get("FFDC_DIR_PATH", os.environ.get("HOME", ".") + "/autoipl/ffdc") target_dir_path = gm.add_trailing_slash(target_dir_path) targ_file_list = [re.sub(".*/", target_dir_path, x) for x in file_list.split(" ")] gc.shell_cmd("mv " + file_list + " " + target_dir_path + " >/dev/null", time_out=600) gp.qprint_timen("New robot log file locations:") gp.qprintn('\n'.join(targ_file_list))