1#!/usr/bin/env python 2 3r""" 4This module provides functions which are useful to plug-ins call-point 5programs that wish to make external robot program calls. 6""" 7 8import sys 9import os 10import subprocess 11import re 12import time 13import imp 14 15import gen_print as gp 16import gen_valid as gv 17import gen_misc as gm 18import gen_cmd as gc 19 20base_path = \ 21 os.path.dirname(os.path.dirname(imp.find_module("gen_robot_print")[1])) +\ 22 os.sep 23 24 25def init_robot_out_parms(extra_prefix=""): 26 r""" 27 Initialize robot output parms such as outputdir, output, etc. 28 29 This function will set global values for the following robot output parms. 30 31 outputdir, output, log, report, loglevel 32 33 This function would typically be called prior to calling 34 create_robot_cmd_string. 35 36 Description of argument(s): 37 extra_prefix An extra prefix to be appended to the 38 default prefix for output file names. 39 """ 40 41 gp.dprint_executing() 42 AUTOBOOT_OPENBMC_NICKNAME = gm.get_mod_global("AUTOBOOT_OPENBMC_NICKNAME") 43 44 # Set values for call to create_robot_cmd_string. 45 # Environment variable TMP_ROBOT_DIR_PATH can be set by the user to 46 # indicate that robot-generated output should initially be written to the 47 # specified temporary directory and then moved to the normal output 48 # location after completion. 49 outputdir =\ 50 os.environ.get("TMP_ROBOT_DIR_PATH", 51 os.environ.get("STATUS_DIR_PATH", 52 os.environ.get("HOME", ".") 53 + "/status")) 54 outputdir = gm.add_trailing_slash(outputdir) 55 seconds = time.time() 56 loc_time = time.localtime(seconds) 57 time_string = time.strftime("%y%m%d.%H%M%S", loc_time) 58 file_prefix = AUTOBOOT_OPENBMC_NICKNAME + "." + extra_prefix +\ 59 time_string + "." 60 # Environment variable SAVE_STATUS_POLICY governs when robot-generated 61 # output files (e.g. the log.html) will be moved from TMP_ROBOT_DIR_PATH 62 # to FFDC_DIR_PATH. Valid values are "ALWAYS", "NEVER" and "FAIL". 63 SAVE_STATUS_POLICY = os.environ.get("SAVE_STATUS_POLICY", "ALWAYS") 64 if SAVE_STATUS_POLICY == "NEVER": 65 output = "NONE" 66 log = "NONE" 67 report = "NONE" 68 else: 69 output = file_prefix + "output.xml" 70 log = file_prefix + "log.html" 71 report = file_prefix + "report.html" 72 loglevel = "TRACE" 73 74 # Make create_robot_cmd_string values global. 75 gm.set_mod_global(outputdir) 76 gm.set_mod_global(output) 77 gm.set_mod_global(log) 78 gm.set_mod_global(report) 79 gm.set_mod_global(loglevel) 80 81 82def init_robot_test_base_dir_path(): 83 r""" 84 Initialize and validate the environment variable, ROBOT_TEST_BASE_DIR_PATH 85 and set corresponding global variable ROBOT_TEST_RUNNING_FROM_SB. 86 87 If ROBOT_TEST_BASE_DIR_PATH is already set, this function will merely 88 validate it. This function will also set environment variable 89 ROBOT_TEST_RUNNING_FROM_SB when ROBOT_TEST_BASE_DIR_PATH is not pre-set. 90 """ 91 92 # ROBOT_TEST_BASE_DIR_PATH will be set as follows: 93 # This function will determine whether we are running in a user sandbox 94 # or from a standard apolloxxx environment. 95 # - User sandbox: 96 # If there is a <developer's home dir>/git/openbmc-test-automation/, 97 # ROBOT_TEST_BASE_DIR_PATH will be set to that path. Otherwise, we set it 98 # to <program dir path>/git/openbmc-test-automation/ 99 # - Not in user sandbox: 100 # ROBOT_TEST_BASE_DIR_PATH will be set to <program dir 101 # path>/git/openbmc-test-automation/ 102 103 ROBOT_TEST_BASE_DIR_PATH = os.environ.get('ROBOT_TEST_BASE_DIR_PATH', "") 104 ROBOT_TEST_RUNNING_FROM_SB = \ 105 int(os.environ.get('ROBOT_TEST_RUNNING_FROM_SB', "0")) 106 if ROBOT_TEST_BASE_DIR_PATH == "": 107 # ROBOT_TEST_BASE_DIR_PATH was not set by user/caller. 108 AUTOIPL_VERSION = os.environ.get('AUTOIPL_VERSION', '') 109 if AUTOIPL_VERSION == "": 110 ROBOT_TEST_BASE_DIR_PATH = base_path 111 else: 112 suffix = "git/openbmc-test-automation/" 113 114 # Determine whether we're running out of a developer sandbox or 115 # simply out of an apolloxxx/bin path. 116 shell_rc, out_buf = gc.shell_cmd('dirname $(which gen_print.py)', 117 quiet=(not debug), print_output=0) 118 executable_base_dir_path = os.path.realpath(out_buf.rstrip()) + "/" 119 apollo_dir_path = os.environ['AUTO_BASE_PATH'] + AUTOIPL_VERSION +\ 120 "/bin/" 121 developer_home_dir_path = re.sub('/sandbox.*', '', 122 executable_base_dir_path) 123 developer_home_dir_path = \ 124 gm.add_trailing_slash(developer_home_dir_path) 125 gp.dprint_vars(executable_base_dir_path, developer_home_dir_path, 126 apollo_dir_path) 127 128 ROBOT_TEST_RUNNING_FROM_SB = 0 129 if executable_base_dir_path != apollo_dir_path: 130 ROBOT_TEST_RUNNING_FROM_SB = 1 131 gp.dprint_vars(ROBOT_TEST_RUNNING_FROM_SB) 132 ROBOT_TEST_BASE_DIR_PATH = developer_home_dir_path + suffix 133 if not os.path.isdir(ROBOT_TEST_BASE_DIR_PATH): 134 gp.dprint_timen("NOTE: Sandbox directory " 135 + ROBOT_TEST_BASE_DIR_PATH + " does not" 136 + " exist.") 137 # Fall back to the apollo dir path. 138 ROBOT_TEST_BASE_DIR_PATH = apollo_dir_path + suffix 139 else: 140 # Use to the apollo dir path. 141 ROBOT_TEST_BASE_DIR_PATH = apollo_dir_path + suffix 142 143 if not gv.valid_value(ROBOT_TEST_BASE_DIR_PATH): 144 return False 145 gp.dprint_vars(ROBOT_TEST_RUNNING_FROM_SB, ROBOT_TEST_BASE_DIR_PATH) 146 if not gv.valid_dir_path(ROBOT_TEST_BASE_DIR_PATH): 147 return False 148 149 ROBOT_TEST_BASE_DIR_PATH = gm.add_trailing_slash(ROBOT_TEST_BASE_DIR_PATH) 150 gm.set_mod_global(ROBOT_TEST_BASE_DIR_PATH) 151 os.environ['ROBOT_TEST_BASE_DIR_PATH'] = ROBOT_TEST_BASE_DIR_PATH 152 153 gm.set_mod_global(ROBOT_TEST_RUNNING_FROM_SB) 154 os.environ['ROBOT_TEST_RUNNING_FROM_SB'] = str(ROBOT_TEST_RUNNING_FROM_SB) 155 156 157raw_robot_file_search_path = "${ROBOT_TEST_BASE_DIR_PATH}:" +\ 158 "${ROBOT_TEST_BASE_DIR_PATH}tests:${ROBOT_TEST_BASE_DIR_PATH}extended:" +\ 159 "${ROBOT_TEST_BASE_DIR_PATH}scratch:${PATH}" 160 161 162def init_robot_file_path(robot_file_path): 163 r""" 164 Determine full path name for the file path passed in robot_file_path and 165 return it. 166 167 If robot_file_path contains a fully qualified path name, this function 168 will verify that the file exists. If robot_file_path contains a relative 169 path, this function will search for the file and set robot_file_path so 170 that it contains the absolute path to the robot file. This function will 171 search for the robot file using the raw_robot_file_search_path (defined 172 above). Note that if ROBOT_TEST_BASE_DIR_PATH is not set, this function 173 will call init_robot_test_base_dir_path to set it. 174 175 Description of arguments: 176 robot_file_path The absolute or relative path to a robot 177 file. 178 """ 179 180 if not gv.valid_value(robot_file_path): 181 raise ValueError('Programmer error.') 182 183 try: 184 if ROBOT_TEST_BASE_DIR_PATH is NONE: 185 init_robot_test_base_dir_path() 186 except NameError: 187 init_robot_test_base_dir_path() 188 189 if not re.match(r".*\.(robot|py)$", robot_file_path): 190 # No suffix so we'll assign one of "\.robot". 191 robot_file_path = robot_file_path + ".robot" 192 193 abs_path = 0 194 if robot_file_path[0:1] == "/": 195 abs_path = 1 196 197 gp.dprint_vars(abs_path, robot_file_path) 198 199 if not abs_path: 200 cmd_buf = "echo -n \"" + raw_robot_file_search_path + "\"" 201 shell_rc, out_buf = gc.shell_cmd(cmd_buf, quiet=(not debug), 202 print_output=0) 203 robot_file_search_paths = out_buf 204 gp.dprint_var(robot_file_search_paths) 205 robot_file_search_paths_list = robot_file_search_paths.split(':') 206 for search_path in robot_file_search_paths_list: 207 search_path = gm.add_trailing_slash(search_path) 208 candidate_file_path = search_path + robot_file_path 209 gp.dprint_var(candidate_file_path) 210 if os.path.isfile(candidate_file_path): 211 gp.dprint_timen("Found full path to " + robot_file_path + ".") 212 robot_file_path = candidate_file_path 213 break 214 215 gp.dprint_var(robot_file_path) 216 if not gv.valid_file_path(robot_file_path): 217 raise ValueError('Programmer error.') 218 219 return robot_file_path 220 221 222def get_robot_parm_names(): 223 r""" 224 Return a list containing all of the long parm names (e.g. --outputdir) 225 supported by the robot program. Double dashes are not included in the 226 names returned. 227 """ 228 229 cmd_buf = "robot -h | egrep " +\ 230 "'^([ ]\\-[a-zA-Z0-9])?[ ]+--[a-zA-Z0-9]+[ ]+' | sed -re" +\ 231 " s'/.*\\-\\-//g' -e s'/ .*//g' | sort -u" 232 shell_rc, out_buf = gc.shell_cmd(cmd_buf, quiet=1, print_output=0) 233 234 return out_buf.split("\n") 235 236 237def create_robot_cmd_string(robot_file_path, *parms): 238 r""" 239 Create a robot command string and return it. On failure, return an empty 240 string. 241 242 Description of arguments: 243 robot_file_path The path to the robot file to be run. 244 parms The list of parms to be included in the 245 command string. The name of each variable 246 in this list must be the same as the name 247 of the corresponding parm. This function 248 figures out that name. This function is 249 also able to distinguish robot parms (e.g. 250 --outputdir) from robot program parms (all 251 other parms which will be passed as "-v 252 PARM_NAME:parm_value").. 253 254 Example: 255 256 The following call to this function... 257 cmd_buf = create_robot_cmd_string("tools/start_sol_console.robot", 258 OPENBMC_HOST, quiet, test_mode, debug, outputdir, output, log, report) 259 260 Would return a string something like this. 261 robot -v OPENBMC_HOST:beye6 -v quiet:0 -v test_mode:1 -v debug:1 262 --outputdir=/gsa/ausgsa/projects/a/status 263 --output=beye6.OS_Console.output.xml --log=beye6.OS_Console.log.html 264 --report=beye6.OS_Console.report.html tools/start_sol_console.robot 265 """ 266 267 robot_file_path = init_robot_file_path(robot_file_path) 268 269 robot_parm_names = get_robot_parm_names() 270 271 robot_parm_list = [] 272 273 stack_frame = 2 274 ix = 2 275 for arg in parms: 276 parm = arg 277 parm = gm.quote_bash_parm(gm.escape_bash_quotes(str(parm))) 278 var_name = gp.get_arg_name(None, ix, stack_frame) 279 if var_name in robot_parm_names: 280 p_string = "--" + var_name + "=" + str(parm) 281 robot_parm_list.append(p_string) 282 else: 283 p_string = "-v " + var_name + ":" + str(parm) 284 robot_parm_list.append(p_string) 285 ix += 1 286 287 robot_cmd_buf = "robot " + ' '.join(robot_parm_list) + " " +\ 288 robot_file_path 289 290 return robot_cmd_buf 291 292 293# Global variables to aid in cleanup after running robot_cmd_fnc. 294gcr_last_robot_cmd_buf = "" 295gcr_last_robot_rc = 0 296 297 298def process_robot_output_files(robot_cmd_buf=None, 299 robot_rc=None, 300 gzip=None): 301 r""" 302 Process robot output files which can involve several operations: 303 - If the files are in a temporary location, using SAVE_STATUS_POLICY to 304 decide whether to move them to a permanent location or to delete them. 305 - Gzipping them. 306 307 Description of argument(s): 308 robot_cmd_buf The complete command string used to invoke 309 robot. 310 robot_rc The return code from running the robot 311 command string. 312 gzip Indicates whether robot-generated output 313 should be gzipped. 314 """ 315 316 robot_cmd_buf = gm.dft(robot_cmd_buf, gcr_last_robot_cmd_buf) 317 robot_rc = gm.dft(robot_rc, gcr_last_robot_rc) 318 gzip = gm.dft(gzip, int(os.environ.get("GZIP_ROBOT", "1"))) 319 320 if robot_cmd_buf == "": 321 # This can legitimately occur if this function is called from an 322 # exit_function without the program having ever run robot_cmd_fnc. 323 return 324 325 SAVE_STATUS_POLICY = os.environ.get("SAVE_STATUS_POLICY", "ALWAYS") 326 gp.qprint_vars(SAVE_STATUS_POLICY) 327 328 # When SAVE_STATUS_POLICY is "NEVER" robot output files don't even get 329 # generated. 330 if SAVE_STATUS_POLICY == "NEVER": 331 return 332 333 # Compose file_list based on robot command buffer passed in. 334 robot_cmd_buf_dict = gc.parse_command_string(robot_cmd_buf) 335 outputdir = robot_cmd_buf_dict['outputdir'] 336 outputdir = gm.add_trailing_slash(outputdir) 337 file_list = outputdir + robot_cmd_buf_dict['output'] + " " + outputdir\ 338 + robot_cmd_buf_dict['log'] + " " + outputdir\ 339 + robot_cmd_buf_dict['report'] 340 341 # Double checking that files are present. 342 shell_rc, out_buf = gc.shell_cmd("ls -1 " + file_list + " 2>/dev/null", 343 show_err=0) 344 file_list = re.sub("\n", " ", out_buf.rstrip("\n")) 345 346 if file_list == "": 347 gp.qprint_timen("No robot output files were found in " + outputdir 348 + ".") 349 return 350 gp.qprint_var(robot_rc, gp.hexa()) 351 if SAVE_STATUS_POLICY == "FAIL" and robot_rc == 0: 352 gp.qprint_timen("The call to robot produced no failures." 353 + " Deleting robot output files.") 354 gc.shell_cmd("rm -rf " + file_list) 355 return 356 357 if gzip: 358 gc.shell_cmd("gzip -f " + file_list) 359 # Update the values in file_list. 360 file_list = re.sub(" ", ".gz ", file_list) + ".gz" 361 362 # It TMP_ROBOT_DIR_PATH is set, it means the caller wanted the robot 363 # output initially directed to TMP_ROBOT_DIR_PATH but later moved to 364 # FFDC_DIR_PATH. Otherwise, we're done. 365 366 if os.environ.get("TMP_ROBOT_DIR_PATH", "") is "": 367 return 368 369 # We're directing these to the FFDC dir path so that they'll be subjected 370 # to FFDC cleanup. 371 target_dir_path = os.environ.get("FFDC_DIR_PATH", 372 os.environ.get("HOME", ".") 373 + "/ffdc") 374 target_dir_path = gm.add_trailing_slash(target_dir_path) 375 376 targ_file_list = [re.sub(".*/", target_dir_path, x) 377 for x in file_list.split(" ")] 378 379 gc.shell_cmd("mv " + file_list + " " + target_dir_path + " >/dev/null", 380 time_out=600) 381 382 gp.qprint_timen("New robot log file locations:") 383 gp.qprintn('\n'.join(targ_file_list)) 384 385 386def robot_cmd_fnc(robot_cmd_buf, 387 robot_jail=os.environ.get('ROBOT_JAIL', '')): 388 r""" 389 Run the robot command string. 390 391 This function will set the various PATH variables correctly so that you 392 are running the proper version of all imported files, etc. 393 394 Description of argument(s): 395 robot_cmd_buf The complete robot command string. 396 robot_jail Indicates that this is to run in "robot 397 jail" meaning without visibility to any 398 apolloxxx import files, programs, etc. 399 """ 400 401 if not gv.valid_value(robot_cmd_buf): 402 return False 403 404 # Set global variables to aid in cleanup with process_robot_output_files. 405 global gcr_last_robot_cmd_buf 406 global gcr_last_robot_rc 407 gcr_last_robot_cmd_buf = robot_cmd_buf 408 409 # Get globals set by init_robot_test_base_dir_path(). 410 module = sys.modules["__main__"] 411 try: 412 ROBOT_TEST_BASE_DIR_PATH = getattr(module, "ROBOT_TEST_BASE_DIR_PATH") 413 except NameError: 414 init_robot_test_base_dir_path() 415 ROBOT_TEST_BASE_DIR_PATH = getattr(module, "ROBOT_TEST_BASE_DIR_PATH") 416 417 ROBOT_TEST_RUNNING_FROM_SB = \ 418 gm.get_mod_global("ROBOT_TEST_RUNNING_FROM_SB") 419 420 if robot_jail == "": 421 if ROBOT_TEST_RUNNING_FROM_SB: 422 robot_jail = 0 423 else: 424 robot_jail = 1 425 426 robot_jail = int(robot_jail) 427 ROBOT_JAIL = os.environ.get('ROBOT_JAIL', '') 428 gp.dprint_vars(ROBOT_TEST_BASE_DIR_PATH, ROBOT_TEST_RUNNING_FROM_SB, 429 ROBOT_JAIL, robot_jail) 430 431 OBMC_TOOLS_BASE_DIR_PATH = \ 432 os.path.dirname(ROBOT_TEST_BASE_DIR_PATH.rstrip("/")) \ 433 + "/openbmc-tools/" 434 openbmctool_dir_path = OBMC_TOOLS_BASE_DIR_PATH + "thalerj" 435 436 # Save PATH and PYTHONPATH to be restored later. 437 os.environ["SAVED_PYTHONPATH"] = os.environ.get("PYTHONPATH", "") 438 os.environ["SAVED_PATH"] = os.environ.get("PATH", "") 439 440 if robot_jail: 441 # Make sure required programs like python and robot can be found in 442 # the new restricted PATH. 443 required_programs = "python robot" 444 # It is expected that there will be a "python" program in the tool 445 # base bin path which is really a link to select_version. Ditto for 446 # "robot". Call each with the --print_only option to get the paths to 447 # the "real" programs. 448 cmd_buf = "for program in " + required_programs \ 449 + " ; do dirname $(${program} --print_only) ; done 2>/dev/null" 450 rc, out_buf = gc.shell_cmd(cmd_buf, quiet=1, print_output=0) 451 PYTHONPATH = ROBOT_TEST_BASE_DIR_PATH + "lib" 452 NEW_PATH_LIST = [ROBOT_TEST_BASE_DIR_PATH + "bin"] 453 NEW_PATH_LIST.extend(list(set(out_buf.rstrip("\n").split("\n")))) 454 NEW_PATH_LIST.extend(["/usr/local/sbin", "/usr/local/bin", "/usr/sbin", 455 "/usr/bin", "/sbin", "/bin", 456 openbmctool_dir_path]) 457 PATH = ":".join(NEW_PATH_LIST) 458 else: 459 PYTHONPATH = os.environ.get('PYTHONPATH', '') + ":" +\ 460 ROBOT_TEST_BASE_DIR_PATH + "lib" 461 PATH = os.environ.get('PATH', '') + ":" + ROBOT_TEST_BASE_DIR_PATH +\ 462 "bin" + ":" + openbmctool_dir_path 463 464 os.environ['PYTHONPATH'] = PYTHONPATH 465 os.environ['PATH'] = PATH 466 gp.dprint_vars(PATH, PYTHONPATH) 467 468 os.environ['FFDC_DIR_PATH_STYLE'] = os.environ.get('FFDC_DIR_PATH_STYLE', 469 '1') 470 test_mode = getattr(module, "test_mode") 471 472 gp.qpissuing(robot_cmd_buf, test_mode) 473 if test_mode: 474 os.environ["PATH"] = os.environ.get("SAVED_PATH", "") 475 os.environ["PYTHONPATH"] = os.environ.get("SAVED_PYTHONPATH", "") 476 return True 477 478 if quiet: 479 DEVNULL = open(os.devnull, 'wb') 480 stdout = DEVNULL 481 else: 482 stdout = None 483 sub_proc = subprocess.Popen(robot_cmd_buf, stdout=stdout, shell=True) 484 sub_proc.communicate() 485 shell_rc = sub_proc.returncode 486 os.environ["PATH"] = os.environ.get("SAVED_PATH", "") 487 os.environ["PYTHONPATH"] = os.environ.get("SAVED_PYTHONPATH", "") 488 gcr_last_robot_rc = shell_rc 489 process_robot_output_files() 490 if shell_rc != 0: 491 gp.print_var(shell_rc, gp.hexa()) 492 return False 493 494 return True 495