import gen_valid as gv import gen_robot_utils as gru import gen_cmd as gc import bmc_ssh_utils as bsu import commands from robot.libraries.BuiltIn import BuiltIn from robot.utils import DotDict import re import os import sys import imp # We need utils.robot to get keywords like "Get Chassis Power State". gru.my_import_resource("utils.robot") gru.my_import_resource("state_manager.robot") base_path = os.path.dirname( os.path.dirname(imp.find_module("gen_robot_print")[1])) + os.sep sys.path.append(base_path + "data/") # Previously, I had this coded: # import variables as var # However, we ran into a problem where a robot program did this... # Variables ../../lib/ras/variables.py # Prior to doing this... # Library ../lib/state.py # This caused the wrong variables.py file to be selected. Attempts to fix this # have failed so far. For the moment, we will hard-code the value we need from
import gen_robot_utils as gru import gen_cmd as gc import bmc_ssh_utils as bsu from robot.libraries.BuiltIn import BuiltIn from robot.utils import DotDict import re import os import sys import imp # NOTE: Avoid importing utils.robot because utils.robot imports state.py # (indirectly) which will cause failures. gru.my_import_resource("rest_client.robot") base_path = os.path.dirname(os.path.dirname( imp.find_module("gen_robot_print")[1])) + os.sep sys.path.append(base_path + "data/") # Previously, I had this coded: # import variables as var # However, we ran into a problem where a robot program did this... # Variables ../../lib/ras/variables.py # Prior to doing this... # Library ../lib/state.py # This caused the wrong variables.py file to be selected. Attempts to fix this # have failed so far. For the moment, we will hard-code the value we need from # the file.
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)
r""" Provide useful ipmi functions. """ import re import gen_print as gp import gen_misc as gm import gen_cmd as gc import gen_robot_keyword as grk import gen_robot_utils as gru import bmc_ssh_utils as bsu import var_funcs as vf import ipmi_client as ic import tempfile gru.my_import_resource("ipmi_client.robot") from robot.libraries.BuiltIn import BuiltIn def get_sol_info(): r""" Get all SOL info and return it as a dictionary. Example use: Robot code: ${sol_info}= get_sol_info Rpvars sol_info Output: sol_info:
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"): gp.dprint_issuing("import_library(\"" + lib_file_path + "\")") BuiltIn().import_library(lib_file_path) else: gp.dprint_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: gp.print_issuing(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: gp.gp_print(output)
#!/usr/bin/env python r""" Provide useful error log utility keywords. """ import gen_print as gp import sys import os import imp base_path = os.path.dirname( os.path.dirname(imp.find_module("gen_robot_print")[1])) + os.sep sys.path.append(base_path + "data/") import variables as var from robot.libraries.BuiltIn import BuiltIn import gen_robot_utils as gru gru.my_import_resource("logging_utils.robot") def print_error_logs(error_logs, key_list=None): r""" Print the error logs to the console screen. This function provides the following benefits: - It will specify print_var parms for the caller (e.g. hex=1). - It is much easier to call this function than to generate the desired code directly from a robot script. Description of argument(s): error_logs An error log dictionary such as the one returned by the 'Get Error Logs' keyword. key_list The list of keys to be printed. This may
#!/usr/bin/env python r""" This module is the python counterpart to poweroffs.robot. It provides functions for powering off an open bmc machine. """ import gen_robot_print as grp import state as state_mod import gen_robot_utils as gru from robot.libraries.BuiltIn import BuiltIn # We need utils.robot to get keyword "Initiate Power Off". gru.my_import_resource("utils.robot") ############################################################################### def bmc_power_off(): r""" Power the Open BMC machine off and monitor status to verify. """ grp.rprint_timen("Refreshing state data.") state = state_mod.get_state() grp.rprint_var(state) match_state = state_mod.anchor_state(state) grp.rprintn()
#!/usr/bin/env python r""" This module is the python counterpart to utils.robot. It provides many functions for communicating with the Open BMC machine. """ import gen_robot_print as grp import state as state_mod import gen_robot_utils as gru from robot.libraries.BuiltIn import BuiltIn # We need utils.robot to get keyword "Initiate Power On". gru.my_import_resource("utils.robot") ############################################################################### def bmc_power_on(): r""" Power the Open BMC machine on and monitor status to verify. """ grp.rprint_timen("Refreshing state data.") state = state_mod.get_state() grp.rprint_var(state) match_state = state_mod.anchor_state(state) grp.rprintn() cmd_buf = ["Initiate Power On", "wait=${0}"] grp.rpissuing_keyword(cmd_buf)
#!/usr/bin/env python r""" Provide useful ipmi functions. """ import gen_misc as gm import gen_robot_keyword as grk import gen_robot_utils as gru import tempfile gru.my_import_resource("ipmi_client.robot") ############################################################################### def get_sol_info(): r""" Get all SOL info and return it as a dictionary. Example use: Robot code: ${sol_info}= get_sol_info Rpvars sol_info Output: sol_info: sol_info[Info]: SOL parameter 'Payload Channel (7)' not supported - defaulting to 0x0e sol_info[Character Send Threshold]: 1 sol_info[Force Authentication]: true sol_info[Privilege Level]: USER