def print_obj(self): r""" Print the fields of this object to stdout. This would normally be for debug purposes. """ grp.rprint(self.sprint_obj())
def check_state(match_state, invert=0, print_string="", openbmc_host="", openbmc_username="", openbmc_password="", os_host="", os_username="", os_password="", quiet=None): r""" Check that the Open BMC machine's composite state matches the specified state. On success, this keyword returns the machine's composite state as a dictionary. Description of arguments: match_state A dictionary whose key/value pairs are "state field"/ "state value". The state value is interpreted as a regular expression. Example call from robot: ${match_state}= Create Dictionary chassis=^On$ ... bmc=^Ready$ ... boot_progress=^OSStart$ ${state}= Check State &{match_state} invert If this flag is set, this function will succeed if the states do NOT match. print_string This function will print this string to the console prior to getting the state. openbmc_host The DNS name or IP address of the BMC. This defaults to global ${OPENBMC_HOST}. openbmc_username The username to be used to login to the BMC. This defaults to global ${OPENBMC_USERNAME}. openbmc_password The password to be used to login to the BMC. This defaults to global ${OPENBMC_PASSWORD}. os_host The DNS name or IP address of the operating system. This defaults to global ${OS_HOST}. os_username The username to be used to login to the OS. This defaults to global ${OS_USERNAME}. os_password The password to be used to login to the OS. This defaults to global ${OS_PASSWORD}. quiet Indicates whether status details should be written to the console. Defaults to either global value of ${QUIET} or to 1. """ quiet = int(gp.get_var_value(quiet, 0)) grp.rprint(print_string) req_states = match_state.keys() # Initialize state. state = get_state(openbmc_host=openbmc_host, openbmc_username=openbmc_username, openbmc_password=openbmc_password, os_host=os_host, os_username=os_username, os_password=os_password, req_states=req_states, quiet=quiet) if not quiet: gp.print_var(state) match = compare_states(state, match_state) if invert and match: fail_msg = "The current state of the machine matches the match" +\ " state:\n" + gp.sprint_varx("state", state) BuiltIn().fail("\n" + gp.sprint_error(fail_msg)) elif not invert and not match: fail_msg = "The current state of the machine does NOT match the" +\ " match state:\n" +\ gp.sprint_varx("state", state) BuiltIn().fail("\n" + gp.sprint_error(fail_msg)) return state
def cmd_fnc(cmd_buf, quiet=None, test_mode=None, debug=0, print_output=1, show_err=1): r""" Run the given command in a shell and return the shell return code. Description of arguments: cmd_buf The command string to be run in a shell. quiet Indicates whether this function should run the pissuing() function prints an "Issuing: <cmd string>" to stdout. test_mode If test_mode is set, this function will not actually run the command. debug If debug is set, this function will print extra debug info. print_output If this is set, this function will print the stdout/stderr generated by the shell command. show_err If show_err is set, this function will print a standardized error report if the shell command returns non-zero. """ quiet = int(gm.global_default(quiet, 0)) test_mode = int(gm.global_default(test_mode, 0)) if debug: gp.print_vars(cmd_buf, quiet, test_mode, debug) err_msg = gv.svalid_value(cmd_buf) if err_msg != "": raise ValueError(err_msg) if not quiet: gp.pissuing(cmd_buf, test_mode) if test_mode: return 0, "" sub_proc = subprocess.Popen(cmd_buf, bufsize=1, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out_buf = "" for line in sub_proc.stdout: out_buf += line if not print_output: continue if robot_env: grp.rprint(line) else: sys.stdout.write(line) if print_output and not robot_env: sys.stdout.flush() sub_proc.communicate() shell_rc = sub_proc.returncode if shell_rc != 0 and show_err: if robot_env: grp.rprint_error_report("The prior command failed.\n" + gp.sprint_var(shell_rc, 1)) else: gp.print_error_report("The prior command failed.\n" + gp.sprint_var(shell_rc, 1)) return shell_rc, out_buf
def cmd_fnc(cmd_buf, quiet=None, test_mode=None, debug=0, print_output=1, show_err=1, return_stderr=0): r""" Run the given command in a shell and return the shell return code and the output. Description of arguments: cmd_buf The command string to be run in a shell. quiet Indicates whether this function should run the print_issuing() function which prints "Issuing: <cmd string>" to stdout. test_mode If test_mode is set, this function will not actually run the command. If print_output is set, it will print "(test_mode) Issuing: <cmd string>" to stdout. debug If debug is set, this function will print extra debug info. print_output If this is set, this function will print the stdout/stderr generated by the shell command. show_err If show_err is set, this function will print a standardized error report if the shell command returns non-zero. return_stderr If return_stderr is set, this function will process the stdout and stderr streams from the shell command separately. It will also return stderr in addition to the return code and the stdout. """ # Determine default values. quiet = int(gm.global_default(quiet, 0)) test_mode = int(gm.global_default(test_mode, 0)) if debug: gp.print_vars(cmd_buf, quiet, test_mode, debug) err_msg = gv.svalid_value(cmd_buf) if err_msg != "": raise ValueError(err_msg) if not quiet: gp.pissuing(cmd_buf, test_mode) if test_mode: if return_stderr: return 0, "", "" else: return 0, "" if return_stderr: err_buf = "" stderr = subprocess.PIPE else: stderr = subprocess.STDOUT sub_proc = subprocess.Popen(cmd_buf, bufsize=1, shell=True, stdout=subprocess.PIPE, stderr=stderr) out_buf = "" if return_stderr: for line in sub_proc.stderr: err_buf += line if not print_output: continue if robot_env: grp.rprint(line) else: sys.stdout.write(line) for line in sub_proc.stdout: out_buf += line if not print_output: continue if robot_env: grp.rprint(line) else: sys.stdout.write(line) if print_output and not robot_env: sys.stdout.flush() sub_proc.communicate() shell_rc = sub_proc.returncode if shell_rc != 0 and show_err: err_msg = "The prior command failed.\n" + gp.sprint_var(shell_rc, 1) if not print_output: err_msg += "out_buf:\n" + out_buf if robot_env: grp.rprint_error_report(err_msg) else: gp.print_error_report(err_msg) if return_stderr: return shell_rc, out_buf, err_buf else: return shell_rc, out_buf
def my_run_keywords(lib_file_path, keyword_string, quiet=0, test_mode=0): r""" Run the keywords in the keyword string. Description of arguments: lib_file_path The path to a library or resource needed to run the keywords. This may contain a colon-delimited list of library/resource paths. keyword_string The keyword string to be run by this function. If this keyword string contains " ; " anywhere, it will be taken to be multiple keyword strings. Each keyword may also include a variable assignment. Example: ${my_var}= My Keyword quiet If this parameter is set to "1", this program will print only essential information, i.e. it will not echo parameters, echo commands, print the total run time, etc. test_mode This means that this program should go through all the motions but not actually do anything substantial. """ # NOTE: During code review the following question was raised: Why support # 1) variable assignments 2) multiple keywords? Couldn't a user simply # call this program twice to get what they need. If necessary, the user # could take the output of the first call and specify it as a literal on # the second call. # # However, this approach would not work in all cases. The following case # would be such an example: # Let's say the first keyword string is as follows: # Create Dictionary foo=bar # You wish to take the output of that call and specify it as a literal # value when running the following: # Want Dictionary parm=<literal dictionary specification> # The problem is that there is no way to specify a dictionary as a # literal in Robot Framework. # By having this program support variable assignments and multiple # keywords, the user can invoke it with the following keyword string. # ${my_dict}= Create Dictionary foo=bar ; Want Dictionary ${my_dict} # The user can pass multiple lib/resource paths by separating them with a # colon. lib_file_path_list = lib_file_path.split(":") # Get rid of empty entry if it exists. if lib_file_path_list[0] == "": del lib_file_path_list[0] for lib_file_path in lib_file_path_list: if lib_file_path.endswith(".py"): grp.rdprint_issuing("import_library(\"" + lib_file_path + "\")") BuiltIn().import_library(lib_file_path) else: grp.rdprint_issuing("my_import_resource(\"" + lib_file_path + "\")") gru.my_import_resource(lib_file_path) # The user can pass multiple keyword strings by separating them with " ; ". keyword_list = keyword_string.split(" ; ") for keyword_string in keyword_list: cmd_buf = keyword_string.split(" ") if re.match(r"\$\{", cmd_buf[0]): # This looks like an assignment (e.g. ${var}= <keyword>). # We'll extract the variable name, remove element 0 from # cmd_buf and set the global variable with the results # after running the keyword. var_name = cmd_buf[0].strip("${}=") del cmd_buf[0] else: var_name = "" if not quiet: grp.rprint_issuing_keyword(cmd_buf, test_mode) if test_mode: continue output = BuiltIn().run_keyword(*cmd_buf) if var_name != "": BuiltIn().set_global_variable("${" + var_name + "}", output) else: if output is not None: grp.rprint(output)
def shell_cmd(command_string, quiet=None, print_output=1, show_err=1, test_mode=0, time_out=None, max_attempts=1, retry_sleep_time=5, allowed_shell_rcs=[0], ignore_err=None, return_stderr=0, fork=0): r""" Run the given command string in a shell and return a tuple consisting of the shell return code and the output. Description of argument(s): command_string The command string to be run in a shell (e.g. "ls /tmp"). quiet If set to 0, this function will print "Issuing: <cmd string>" to stdout. When the quiet argument is set to None, this function will assign a default value by searching upward in the stack for the quiet variable value. If no such value is found, quiet is set to 0. print_output If this is set, this function will print the stdout/stderr generated by the shell command to stdout. show_err If show_err is set, this function will print a standardized error report if the shell command fails (i.e. if the shell command returns a shell_rc that is not in allowed_shell_rcs). Note: Error text is only printed if ALL attempts to run the command_string fail. In other words, if the command execution is ultimately successful, initial failures are hidden. test_mode If test_mode is set, this function will not actually run the command. If print_output is also set, this function will print "(test_mode) Issuing: <cmd string>" to stdout. A caller should call shell_cmd directly if they wish to have the command string run unconditionally. They should call the t_shell_cmd wrapper (defined below) if they wish to run the command string only if the prevailing test_mode variable is set to 0. time_out A time-out value expressed in seconds. If the command string has not finished executing within <time_out> seconds, it will be halted and counted as an error. max_attempts The max number of attempts that should be made to run the command string. retry_sleep_time The number of seconds to sleep between attempts. allowed_shell_rcs A list of integers indicating which shell_rc values are not to be considered errors. ignore_err Ignore error means that a failure encountered by running the command string will not be raised as a python exception. When the ignore_err argument is set to None, this function will assign a default value by searching upward in the stack for the ignore_err variable value. If no such value is found, ignore_err is set to 1. return_stderr If return_stderr is set, this function will process the stdout and stderr streams from the shell command separately. In such a case, the tuple returned by this function will consist of three values rather than just two: rc, stdout, stderr. fork Run the command string asynchronously (i.e. don't wait for status of the child process and don't try to get stdout/stderr). """ # Assign default values to some of the arguments to this function. quiet = int(gm.dft(quiet, gp.get_stack_var('quiet', 0))) ignore_err = int(gm.dft(ignore_err, gp.get_stack_var('ignore_err', 1))) err_msg = gv.svalid_value(command_string) if err_msg != "": raise ValueError(err_msg) if not quiet: gp.print_issuing(command_string, test_mode) if test_mode: if return_stderr: return 0, "", "" else: return 0, "" # Convert each list entry to a signed value. allowed_shell_rcs = [gm.to_signed(x) for x in allowed_shell_rcs] if return_stderr: stderr = subprocess.PIPE else: stderr = subprocess.STDOUT shell_rc = 0 out_buf = "" err_buf = "" # Write all output to func_history_stdout rather than directly to stdout. # This allows us to decide what to print after all attempts to run the # command string have been made. func_history_stdout will contain the # complete stdout history from the current invocation of this function. func_history_stdout = "" for attempt_num in range(1, max_attempts + 1): sub_proc = subprocess.Popen(command_string, bufsize=1, shell=True, executable='/bin/bash', stdout=subprocess.PIPE, stderr=stderr) out_buf = "" err_buf = "" # Output from this loop iteration is written to func_stdout for later # processing. func_stdout = "" if fork: break command_timed_out = False if time_out is not None: # Designate a SIGALRM handling function and set alarm. signal.signal(signal.SIGALRM, shell_cmd_timed_out) signal.alarm(time_out) try: if return_stderr: for line in sub_proc.stderr: err_buf += line if not print_output: continue func_stdout += line for line in sub_proc.stdout: out_buf += line if not print_output: continue func_stdout += line except IOError: command_timed_out = True sub_proc.communicate() shell_rc = sub_proc.returncode # Restore the original SIGALRM handler and clear the alarm. signal.signal(signal.SIGALRM, original_sigalrm_handler) signal.alarm(0) if shell_rc in allowed_shell_rcs: break err_msg = "The prior shell command failed.\n" if command_timed_out: err_msg += gp.sprint_var(command_timed_out) err_msg += gp.sprint_var(time_out) err_msg += gp.sprint_varx("child_pid", sub_proc.pid) err_msg += gp.sprint_var(attempt_num) err_msg += gp.sprint_var(shell_rc, 1) err_msg += gp.sprint_var(allowed_shell_rcs, 1) if not print_output: if return_stderr: err_msg += "err_buf:\n" + err_buf err_msg += "out_buf:\n" + out_buf if show_err: if robot_env: func_stdout += grp.sprint_error_report(err_msg) else: func_stdout += gp.sprint_error_report(err_msg) func_history_stdout += func_stdout if attempt_num < max_attempts: func_history_stdout += gp.sprint_issuing("time.sleep(" + str(retry_sleep_time) + ")") time.sleep(retry_sleep_time) if shell_rc not in allowed_shell_rcs: func_stdout = func_history_stdout if robot_env: grp.rprint(func_stdout) else: sys.stdout.write(func_stdout) sys.stdout.flush() if shell_rc not in allowed_shell_rcs: if not ignore_err: if robot_env: BuiltIn().fail(err_msg) else: raise ValueError("The prior shell command failed.\n") if return_stderr: return shell_rc, out_buf, err_buf else: return shell_rc, out_buf