def save_plug_in_value(value, plug_in_package_name=None):
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 of the value passed and
use that name in creating the plug-in save file.
Example call:
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.
Description of argument(s):
value The value to be saved.
plug_in_package_name See compose_plug_in_save_dir_path for
details.
"""
# 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.")
gc.shell_cmd("echo '" + str(value) + "' > " + save_file_path)
def delete_plug_in_save_dir():
r"""
Delete the plug_in save directory. See compose_plug_in_save_dir_path for
details.
"""
gc.shell_cmd("rm -rf " + compose_plug_in_save_dir_path())
def save_plug_in_value(value):
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 of the value passed and
use that name in creating the plug-in save file.
Example call:
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.
Description of argument(s):
value The value to be saved.
"""
# 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()
save_file_path = plug_in_save_dir_path + var_name
gp.qprint_timen("Saving \"" + var_name + "\" value.")
gc.shell_cmd("echo '" + str(value) + "' > " + save_file_path)
def delete_plug_in_save_dir():
r"""
Delete the plug_in save directory. See compose_plug_in_save_dir_path for
details.
"""
gc.shell_cmd("rm -rf " + compose_plug_in_save_dir_path())
def delete_plug_in_save_dir(plug_in_package_name=None):
r"""
Delete the plug_in save directory. See compose_plug_in_save_dir_path for details.
Description of argument(s):
plug_in_package_name See compose_plug_in_save_dir_path for details.
"""
gc.shell_cmd("rm -rf " +
compose_plug_in_save_dir_path(plug_in_package_name))
def create_plug_in_save_dir():
r"""
Create a directory suitable for saving plug-in processing data. See
compose_plug_in_save_dir_path for details.
"""
plug_in_save_dir_path = compose_plug_in_save_dir_path()
if os.path.isdir(plug_in_save_dir_path):
return plug_in_save_dir_path
gc.shell_cmd("mkdir -p " + plug_in_save_dir_path)
return plug_in_save_dir_path
def create_plug_in_save_dir():
r"""
Create a directory suitable for saving plug-in processing data. See
compose_plug_in_save_dir_path for details.
"""
plug_in_save_dir_path = compose_plug_in_save_dir_path()
if os.path.isdir(plug_in_save_dir_path):
return plug_in_save_dir_path
gc.shell_cmd("mkdir -p " + plug_in_save_dir_path)
return plug_in_save_dir_path
def get_child_pids(quiet=1):
r"""
Get and return a list of pids representing all first-generation processes
that are the children of the current process.
Example:
children = get_child_pids()
print_var(children)
Output:
children:
children[0]: 9123
Description of argument(s):
quiet Display output to stdout detailing how
this child pids are obtained.
"""
if psutil_imported:
# If "import psutil" worked, find child pids using psutil.
current_process = psutil.Process()
return [x.pid for x in current_process.children(recursive=False)]
else:
# Otherwise, find child pids using shell commands.
print_output = not quiet
ps_cmd_buf = "ps --no-headers --ppid " + str(os.getpid()) +\
" -o pid,args"
# Route the output of ps to a temporary file for later grepping.
# Avoid using " | grep" in the ps command string because it creates
# yet another process which is of no interest to the caller.
temp = tempfile.NamedTemporaryFile()
temp_file_path = temp.name
gc.shell_cmd(ps_cmd_buf + " > " + temp_file_path,
print_output=print_output)
# Sample contents of the temporary file:
# 30703 sleep 2
# 30795 /bin/bash -c ps --no-headers --ppid 30672 -o pid,args >
# /tmp/tmpqqorWY
# Use egrep to exclude the "ps" process itself from the results
# collected with the prior shell_cmd invocation. Only the other
# children are of interest to the caller. Use cut on the grep results
# to obtain only the pid column.
rc, output = \
gc.shell_cmd("egrep -v '" + re.escape(ps_cmd_buf) + "' "
+ temp_file_path + " | cut -c1-5",
print_output=print_output)
# Split the output buffer by line into a list. Strip each element of
# extra spaces and convert each element to an integer.
return map(int, map(str.strip, filter(None, output.split("\n"))))
def get_child_pids(quiet=1):
r"""
Get and return a list of pids representing all first-generation processes
that are the children of the current process.
Example:
children = get_child_pids()
print_var(children)
Output:
children:
children[0]: 9123
Description of argument(s):
quiet Display output to stdout detailing how
this child pids are obtained.
"""
if psutil_imported:
# If "import psutil" worked, find child pids using psutil.
current_process = psutil.Process()
return [x.pid for x in current_process.children(recursive=False)]
else:
# Otherwise, find child pids using shell commands.
print_output = not quiet
ps_cmd_buf = "ps --no-headers --ppid " + str(os.getpid()) +\
" -o pid,args"
# Route the output of ps to a temporary file for later grepping.
# Avoid using " | grep" in the ps command string because it creates
# yet another process which is of no interest to the caller.
temp = tempfile.NamedTemporaryFile()
temp_file_path = temp.name
gc.shell_cmd(ps_cmd_buf + " > " + temp_file_path,
print_output=print_output)
# Sample contents of the temporary file:
# 30703 sleep 2
# 30795 /bin/bash -c ps --no-headers --ppid 30672 -o pid,args >
# /tmp/tmpqqorWY
# Use egrep to exclude the "ps" process itself from the results
# collected with the prior shell_cmd invocation. Only the other
# children are of interest to the caller. Use cut on the grep results
# to obtain only the pid column.
rc, output = \
gc.shell_cmd("egrep -v '" + re.escape(ps_cmd_buf) + "' "
+ temp_file_path + " | cut -c1-5",
print_output=print_output)
# Split the output buffer by line into a list. Strip each element of
# extra spaces and convert each element to an integer.
return map(int, map(str.strip, filter(None, output.split("\n"))))
def software_versions():
r"""
Get the versions for several of the software packages used by
openbmc-test-automation and return as a dictionary.
Example call:
${software_versions}= Software Versions
Rprint Vars software_versions
Example output:
software_versions:
[python]: Python 2.7.12
[robot]: Robot Framework 3.1.2 (Python 3.6.8 on linux)
[firefox]: Mozilla Firefox 54.0
[google-chrome]: Not installed
[Selenium2Library]: 3.0.0
[SeleniumLibrary]: 3.3.1
[SSHLibrary]: 3.3.0
[requests]: 2.22.0
[XvfbRobot]: 1.2.2
[robotremoteserver]: 1.1
[redfish]: 2.1.1
[robotframework-angularjs]: 0.0.10
[robotframework-scplibrary]: 1.2.0
[robotframework-extendedselenium2library]: 0.9.1
[host OS]: Ubuntu 16.04.6 LTS
"""
quiet = 1
versions = collections.OrderedDict()
for package in ['python', 'robot', 'firefox', 'google-chrome']:
# Note: "robot --version" returns 0x00000000000000fb.
# Note: If package does not exist, 0x7f is returned.
rc, version = gc.shell_cmd(package + " --version",
valid_rcs=[0, 0x7f, 0xfb])
versions[package] = "Not installed" if rc == 0x7f else version.rstrip(
'\n')
versions.update(import_versions)
for package in [
'robotframework-angularjs', 'robotframework-scplibrary',
'robotframework-extendedselenium2library'
]:
rc, version = gc.shell_cmd("pip show " + package +
" | grep Version | sed -re 's/.*: //g'")
versions[package] = "Not installed" if not version else version.rstrip(
'\n')
rc, version = gc.shell_cmd("lsb_release -d -s")
versions["host OS"] = "Failed" if not version else version.rstrip('\n')
return versions
def create_plug_in_save_dir(plug_in_package_name=None):
r"""
Create a directory suitable for saving plug-in processing data and return its path name.
See compose_plug_in_save_dir_path for details.
Description of argument(s):
plug_in_package_name See compose_plug_in_save_dir_path for details.
"""
plug_in_save_dir_path = compose_plug_in_save_dir_path(plug_in_package_name)
if os.path.isdir(plug_in_save_dir_path):
return plug_in_save_dir_path
gc.shell_cmd("mkdir -p " + plug_in_save_dir_path)
return plug_in_save_dir_path
def rvalidate_plug_ins(plug_in_dir_paths, quiet=1):
r"""
Call the external validate_plug_ins.py program which validates the plug-in
dir paths given to it. Return a list containing a normalized path for
each plug-in selected.
Description of arguments:
plug_in_dir_paths A colon-separated list of plug-in
directory paths.
quiet If quiet is set to 1, this function will
NOT write status messages to stdout.
"""
cmd_buf = "validate_plug_ins.py \"" + plug_in_dir_paths + "\""
rc, out_buf = gc.shell_cmd(cmd_buf, print_output=0)
if rc != 0:
BuiltIn().fail(
gp.sprint_error("Validate plug ins call failed. See" +
" stderr text for details.\n"))
# plug_in_packages_list = out_buf.split("\n")
plug_in_packages_list = list(filter(None, out_buf.split("\n")))
if len(plug_in_packages_list) == 1 and plug_in_packages_list[0] == "":
return []
return plug_in_packages_list
def init_robot_file_path(robot_file_path):
r"""
Determine full path name for the file path passed in robot_file_path and
return it.
If robot_file_path contains a fully qualified path name, this function
will verify that the file exists. If robot_file_path contains a relative
path, this function will search for the file and set robot_file_path so
that it contains the absolute path to the robot file. This function will
search for the robot file using the raw_robot_file_search_path (defined
above). Note that if ROBOT_TEST_BASE_DIR_PATH is not set, this function
will call init_robot_test_base_dir_path to set it.
Description of arguments:
robot_file_path The absolute or relative path to a robot
file.
"""
if not gv.valid_value(robot_file_path):
raise ValueError('Programmer error.')
try:
if ROBOT_TEST_BASE_DIR_PATH is NONE:
init_robot_test_base_dir_path()
except NameError:
init_robot_test_base_dir_path()
if not re.match(r".*\.(robot|py)$", robot_file_path):
# No suffix so we'll assign one of "\.robot".
robot_file_path = robot_file_path + ".robot"
abs_path = 0
if robot_file_path[0:1] == "/":
abs_path = 1
gp.dprint_vars(abs_path, robot_file_path)
if not abs_path:
cmd_buf = "echo -n \"" + raw_robot_file_search_path + "\""
shell_rc, out_buf = gc.shell_cmd(cmd_buf,
quiet=(not debug),
print_output=0)
robot_file_search_paths = out_buf
gp.dprint_var(robot_file_search_paths)
robot_file_search_paths_list = robot_file_search_paths.split(':')
for search_path in robot_file_search_paths_list:
search_path = gm.add_trailing_slash(search_path)
candidate_file_path = search_path + robot_file_path
gp.dprint_var(candidate_file_path)
if os.path.isfile(candidate_file_path):
gp.dprint_timen("Found full path to " + robot_file_path + ".")
robot_file_path = candidate_file_path
break
gp.dprint_var(robot_file_path)
if not gv.valid_file_path(robot_file_path):
raise ValueError('Programmer error.')
return robot_file_path
def init_robot_file_path(robot_file_path):
r"""
Determine full path name for the file path passed in robot_file_path and
return it.
If robot_file_path contains a fully qualified path name, this function
will verify that the file exists. If robot_file_path contains a relative
path, this function will search for the file and set robot_file_path so
that it contains the absolute path to the robot file. This function will
search for the robot file using the raw_robot_file_search_path (defined
above). Note that if ROBOT_TEST_BASE_DIR_PATH is not set, this function
will call init_robot_test_base_dir_path to set it.
Description of arguments:
robot_file_path The absolute or relative path to a robot
file.
"""
if not gv.valid_value(robot_file_path):
raise ValueError('Programmer error.')
try:
if ROBOT_TEST_BASE_DIR_PATH is NONE:
init_robot_test_base_dir_path()
except NameError:
init_robot_test_base_dir_path()
if not re.match(r".*\.(robot|py)$", robot_file_path):
# No suffix so we'll assign one of "\.robot".
robot_file_path = robot_file_path + ".robot"
abs_path = 0
if robot_file_path[0:1] == "/":
abs_path = 1
gp.dprint_vars(abs_path, robot_file_path)
if not abs_path:
cmd_buf = "echo -n \"" + raw_robot_file_search_path + "\""
shell_rc, out_buf = gc.shell_cmd(cmd_buf, quiet=(not debug),
print_output=0)
robot_file_search_paths = out_buf
gp.dprint_var(robot_file_search_paths)
robot_file_search_paths_list = robot_file_search_paths.split(':')
for search_path in robot_file_search_paths_list:
search_path = gm.add_trailing_slash(search_path)
candidate_file_path = search_path + robot_file_path
gp.dprint_var(candidate_file_path)
if os.path.isfile(candidate_file_path):
gp.dprint_timen("Found full path to " + robot_file_path + ".")
robot_file_path = candidate_file_path
break
gp.dprint_var(robot_file_path)
if not gv.valid_file_path(robot_file_path):
raise ValueError('Programmer error.')
return robot_file_path
def verify_ipmi_user_parm_accepted():
r"""
Deterimine whether the OBMC accepts the '-U' ipmitool option and adjust
the global ipmi_required_options accordingly.
"""
# Assumption: "U" is in the global ipmi_required_options.
global ipmi_required_options
print_output = 0
command_string = create_ipmi_ext_command_string('power status')
rc, stdout = gc.shell_cmd(command_string,
print_output=print_output,
show_err=0,
ignore_err=1)
gp.qprint_var(rc, 1)
if rc == 0:
# The OBMC accepts the ipmitool "-U" option so new further work needs
# to be done.
return
# Remove the "U" option from ipmi_required_options to allow us to create a
# command string without the "U" option.
if 'U' in ipmi_required_options:
del ipmi_required_options[ipmi_required_options.index('U')]
command_string = create_ipmi_ext_command_string('power status')
rc, stdout = gc.shell_cmd(command_string,
print_output=print_output,
show_err=0,
ignore_err=1)
gp.qprint_var(rc, 1)
if rc == 0:
# The "U" option has been removed from the ipmi_required_options
# global variable.
return
message = "Unable to run ipmitool (with or without the '-U' option).\n"
gp.print_error(message)
# Revert to original ipmi_required_options by inserting 'U' right before
# 'P'.
ipmi_required_options.insert(ipmi_required_options.index('P'), 'U')
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 get_robot_parm_names():
r"""
Return a list containing all of the long parm names (e.g. --outputdir) supported by the robot program.
Double dashes are not included in the names returned.
"""
cmd_buf = "robot -h | egrep " +\
"'^([ ]\\-[a-zA-Z0-9])?[ ]+--[a-zA-Z0-9]+[ ]+' | sed -re" +\
" s'/.*\\-\\-//g' -e s'/ .*//g' | sort -u"
shell_rc, out_buf = gc.shell_cmd(cmd_buf, quiet=1, print_output=0)
return out_buf.split("\n")
def get_robot_parm_names():
r"""
Return a list containing all of the long parm names (e.g. --outputdir)
supported by the robot program. Double dashes are not included in the
names returned.
"""
cmd_buf = "robot -h | egrep " +\
"'^([ ]\\-[a-zA-Z0-9])?[ ]+--[a-zA-Z0-9]+[ ]+' | sed -re" +\
" s'/.*\\-\\-//g' -e s'/ .*//g' | sort -u"
shell_rc, out_buf = gc.shell_cmd(cmd_buf, quiet=1, print_output=0)
return out_buf.split("\n")
def collect_service_data(verify=False):
r"""
Run the collect_service_data command and return a list of files generated
by the command.
Description of argument(s):
verify If set, verify that all files which can be
created by collect_service_data did, in
fact, get created.
"""
# Route the output of collect_service_data to a file for easier parsing.
temp = tempfile.NamedTemporaryFile()
temp_file_path = temp.name
openbmctool_execute_command("collect_service_data > " + temp_file_path,
ignore_err=False)
# Isolate the file paths in the collect_service_data output. We're
# looking for output lines like this from which to extract the file paths:
# Inventory collected and stored in /tmp/dummy--2018-09-26_17.59.18/inventory.txt
rc, file_paths = gc.shell_cmd(
"egrep 'collected and' " + temp_file_path
# + " | sed -re 's#.*/tmp#/tmp#g'",
+ " | sed -re 's#[^/]*/#/#'",
quiet=1,
print_output=0)
# Example file_paths value:
# /tmp/dummy--2018-09-26_17.59.18/inventory.txt
# /tmp/dummy--2018-09-26_17.59.18/sensorReadings.txt
# etc.
# Convert from output to list.
collect_service_data_file_paths =\
list(filter(None, file_paths.split("\n")))
if int(verify):
# Create a list of files by stripping the dir names from the elements
# of collect_service_data_file_paths.
files_obtained = [
re.sub(r".*/", "", file_path)
for file_path in collect_service_data_file_paths
]
files_expected = service_data_files()
files_missing = list(set(files_expected) - set(files_obtained))
if len(files_missing) > 0:
gp.printn("collect_service_data output:\n" +
gm.file_to_str(temp_file_path))
err_msg = "The following files are missing from the list of files"
err_msg += " returned by collect_service_data:\n"
err_msg += gp.sprint_var(files_missing)
err_msg += gp.sprint_var(collect_service_data_file_paths)
BuiltIn().fail(gp.sprint_error(err_msg))
return collect_service_data_file_paths
def sprint_process_report(pids):
r"""
Create a process report for the given pids and return it as a string.
Description of argument(s):
pids A list of process IDs for processes to be included in the report.
"""
report = "\n"
cmd_buf = "echo ; ps wwo user,pgrp,pid,ppid,lstart,cmd --forest " + ' '.join(
pids)
report += gp.sprint_issuing(cmd_buf)
rc, outbuf = gc.shell_cmd(cmd_buf, quiet=1)
report += outbuf + "\n"
return report
def execute_ipmi_cmd(cmd_string,
ipmi_cmd_type='inband',
print_output=1,
ignore_err=0):
r"""
Run the given command string as an IPMI command and return the stdout,
stderr and the return code.
Description of argument(s):
cmd_string The command string to be run as an IPMI
command.
ipmi_cmd_type 'inband' or 'external'.
print_output If this is set, this function will print
the stdout/stderr generated by
the IPMI command.
ignore_err Ignore error means that a failure
encountered by running the command
string will not be raised as a python
exception.
"""
if ipmi_cmd_type == 'inband':
IPMI_INBAND_CMD = BuiltIn().get_variable_value("${IPMI_INBAND_CMD}")
cmd_buf = IPMI_INBAND_CMD + " " + cmd_string
return bsu.os_execute_command(cmd_buf,
print_out=print_output,
ignore_err=ignore_err)
if ipmi_cmd_type == 'external':
cmd_buf = BuiltIn().get_variable_value("${IPMI_EXT_CMD}")
IPMI_USER_OPTIONS =\
BuiltIn().get_variable_value("${IPMI_USER_OPTIONS}")
if IPMI_USER_OPTIONS != "":
cmd_buf += " " + IPMI_USER_OPTIONS
cmd_buf += " -P " + BuiltIn().get_variable_value("${IPMI_PASSWORD}")
cmd_buf += " " + BuiltIn().get_variable_value("${HOST}")
cmd_buf += " " + BuiltIn().get_variable_value("${OPENBMC_HOST}")
cmd_buf += " " + cmd_string
rc, stdout, stderr = gc.shell_cmd(cmd_buf,
print_output=print_output,
ignore_err=ignore_err,
return_stderr=1)
return stdout, stderr, rc
def valid_date_time(var_value, var_name=None):
r"""
The variable value is valid if it can be interpreted as a date/time (e.g. "14:49:49.981", "tomorrow",
etc.) by the linux date command.
Description of argument(s):
var_value The value being validated.
"""
error_message = ""
rc, out_buf = gc.shell_cmd("date -d '" + str(var_value) + "'", quiet=1, show_err=0, ignore_err=1)
if rc:
var_name = get_var_name(var_name)
error_message += "Invalid date/time value:\n"
error_message += gp.sprint_varx(var_name, var_value,
gp.blank() | gp.show_type())
return process_error_message(error_message)
return process_error_message(error_message)
def nping(host=openbmc_host, parse_results=1, **options):
r"""
Run the nping command and return the results either as a string or as a dictionary.
Do a 'man nping' for a complete description of the nping utility.
Note that any valid nping argument may be specified as a function argument.
Example robot code:
${nping_result}= Nping delay=${delay} count=${count} icmp=${None} icmp-type=echo
Rprint Vars nping_result
Resulting output:
nping_result:
[max_rtt]: 0.534ms
[min_rtt]: 0.441ms
[avg_rtt]: 0.487ms
[raw_packets_sent]: 4 (112B)
[rcvd]: 2 (92B)
[lost]: 2 (50.00%)
[percent_lost]: 50.0
Description of argument(s):
host The host name or IP of the target of the
nping command.
parse_results 1 or True indicates that this function
should parse the nping results and return
a dictionary rather than the raw nping
output. See the parse_nping_output()
function for details on the dictionary
structure.
options Zero or more options accepted by the nping
command. Do a 'man nping' for details.
"""
command_string = gc.create_command_string('nping', host, options)
rc, output = gc.shell_cmd(command_string, print_output=0, ignore_err=0)
if parse_results:
return parse_nping_output(output)
return output
def valid_program(var_value, var_name=None):
r"""
The variable value is valid if it contains the name of a program which can be located using the "which"
command.
Description of argument(s):
var_value The value being validated.
"""
error_message = ""
rc, out_buf = gc.shell_cmd("which " + var_value, quiet=1, show_err=0,
ignore_err=1)
if rc:
var_name = get_var_name(var_name)
error_message += "The following required program could not be found"
error_message += " using the $PATH environment variable:\n"
error_message += gp.sprint_varx(var_name, var_value, gp.blank())
PATH = os.environ.get("PATH", "").split(":")
error_message += "\n"
error_message += gp.sprint_var(PATH)
return process_error_message(error_message)
def execute_ipmi_cmd(cmd_string,
ipmi_cmd_type='inband',
print_output=1,
ignore_err=0,
**options):
r"""
Run the given command string as an IPMI command and return the stdout,
stderr and the return code.
Description of argument(s):
cmd_string The command string to be run as an IPMI
command.
ipmi_cmd_type 'inband' or 'external'.
print_output If this is set, this function will print
the stdout/stderr generated by
the IPMI command.
ignore_err Ignore error means that a failure
encountered by running the command
string will not be raised as a python
exception.
options These are passed directly to the
create_ipmi_ext_command_string function.
See that function's prolog for details.
"""
if ipmi_cmd_type == 'inband':
IPMI_INBAND_CMD = BuiltIn().get_variable_value("${IPMI_INBAND_CMD}")
cmd_buf = IPMI_INBAND_CMD + " " + cmd_string
return bsu.os_execute_command(cmd_buf,
print_out=print_output,
ignore_err=ignore_err)
if ipmi_cmd_type == 'external':
cmd_buf = ic.create_ipmi_ext_command_string(cmd_string, **options)
rc, stdout, stderr = gc.shell_cmd(cmd_buf,
print_output=print_output,
ignore_err=ignore_err,
return_stderr=1)
return stdout, stderr, rc
def openbmctool_execute_command(command_string,
*args,
**kwargs):
r"""
Run the command string as an argument to the openbmctool.py program and
return the stdout and the return code.
This function provides several benefits versus calling shell_cmd directly:
- This function will obtain the global values for OPENBMC_HOST,
OPENBMC_USERNAME, etc.
- This function will compose the openbmctool.py command string which
includes the caller's command_string.
- The openbmctool.py produces additional text that clutters the output.
This function will remove such text. Example:
Attempting login...
<actual output>
User root has been logged out
NOTE: If you have pipe symbols in your command_string, they must be
surrounded by a single space on each side (see example below).
Example code:
${rc} ${output}= Openbmctool Execute Command fru status | head -n 2
Example output:
#(CDT) 2018/09/19 15:16:58 - Issuing: set -o pipefail ; openbmctool.py -H hostname -U root -P ********
... fru status | tail -n +1 | egrep -v 'Attempting login|User [^ ]+ hasbeen logged out' | head -n 2
Component | Is a FRU | Present | Functional | Has Logs
cpu0 | Yes | Yes | Yes | No
Description of arguments:
command_string The command string to be passed to the
openbmctool.py program.
All remaining arguments are passed directly to shell_cmd. See the
shell_cmd prolog for details on allowable arguments. The caller may code
them directly as in this example:
openbmctool_execute_command("my command", quiet=1, max_attempts=2).
Python will do the work of putting these values into args/kwargs.
"""
if not gv.valid_value(command_string):
return "", "", 1
# Get global BMC variable values.
openbmc_host = BuiltIn().get_variable_value("${OPENBMC_HOST}", default="")
openbmc_username = BuiltIn().get_variable_value("${OPENBMC_USERNAME}",
default="")
openbmc_password = BuiltIn().get_variable_value("${OPENBMC_PASSWORD}",
default="")
if not gv.valid_value(openbmc_host):
return "", "", 1
if not gv.valid_value(openbmc_username):
return "", "", 1
if not gv.valid_value(openbmc_password):
return "", "", 1
# Break the caller's command up into separate piped commands. For
# example, the user may have specified "fru status | head -n 2" which
# would be broken into 2 list elements. We will also break on ">"
# (re-direct).
pipeline = list(map(str.strip, re.split(r' ([\|>]) ',
str(command_string))))
# The "tail" command below prevents a "egrep: write error: Broken pipe"
# error if the user is piping the output to a sub-process.
# Use "egrep -v" to get rid of editorial output from openbmctool.py.
pipeline.insert(1, "| tail -n +1 | egrep -v 'Attempting login|User [^ ]+"
" has been logged out'")
command_string = "set -o pipefail ; python3 $(which openbmctool.py) -H "\
+ openbmc_host + " -U " + openbmc_username + " -P " + openbmc_password\
+ " " + " ".join(pipeline)
return gc.shell_cmd(command_string, *args, **kwargs)
def robot_cmd_fnc(robot_cmd_buf,
robot_jail=os.environ.get('ROBOT_JAIL', ''),
quiet=None,
test_mode=0):
r"""
Run the robot command string.
This function will set the various PATH variables correctly so that you are running the proper version of
all imported files, etc.
Description of argument(s):
robot_cmd_buf The complete robot command string.
robot_jail Indicates that this is to run in "robot jail" meaning without visibility
to any apolloxxx import files, programs, etc.
test_mode If test_mode is set, this function will not actually run the command.
"""
quiet = int(gm.dft(quiet, gp.get_stack_var('quiet', 0)))
gv.valid_value(robot_cmd_buf)
# Set global variables to aid in cleanup with process_robot_output_files.
global gcr_last_robot_cmd_buf
global gcr_last_robot_rc
gcr_last_robot_cmd_buf = robot_cmd_buf
# Get globals set by init_robot_test_base_dir_path().
module = sys.modules["__main__"]
try:
ROBOT_TEST_BASE_DIR_PATH = getattr(module, "ROBOT_TEST_BASE_DIR_PATH")
except NameError:
init_robot_test_base_dir_path()
ROBOT_TEST_BASE_DIR_PATH = getattr(module, "ROBOT_TEST_BASE_DIR_PATH")
ROBOT_TEST_RUNNING_FROM_SB = gm.get_mod_global(
"ROBOT_TEST_RUNNING_FROM_SB")
OPENBMCTOOL_DIR_PATH = gm.get_mod_global("OPENBMCTOOL_DIR_PATH")
if robot_jail == "":
if ROBOT_TEST_RUNNING_FROM_SB:
robot_jail = 0
else:
robot_jail = 1
robot_jail = int(robot_jail)
ROBOT_JAIL = os.environ.get('ROBOT_JAIL', '')
gp.dprint_vars(ROBOT_TEST_BASE_DIR_PATH, ROBOT_TEST_RUNNING_FROM_SB,
ROBOT_JAIL, robot_jail)
# Save PATH and PYTHONPATH to be restored later.
os.environ["SAVED_PYTHONPATH"] = os.environ.get("PYTHONPATH", "")
os.environ["SAVED_PATH"] = os.environ.get("PATH", "")
if robot_jail:
# Make sure required programs like python and robot can be found in the new restricted PATH.
required_programs = "python robot"
# It is expected that there will be a "python" program in the tool base bin path which is really a
# link to select_version. Ditto for "robot". Call each with the --print_only option to get the
# paths to the "real" programs.
cmd_buf = "for program in " + required_programs \
+ " ; do dirname $(${program} --print_only) ; done 2>/dev/null"
rc, out_buf = gc.shell_cmd(cmd_buf, quiet=1, print_output=0)
PYTHONPATH = ROBOT_TEST_BASE_DIR_PATH + "lib"
NEW_PATH_LIST = [ROBOT_TEST_BASE_DIR_PATH + "bin"]
NEW_PATH_LIST.extend(list(set(out_buf.rstrip("\n").split("\n"))))
NEW_PATH_LIST.extend([
"/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin",
"/sbin", "/bin",
OPENBMCTOOL_DIR_PATH.rstrip('/')
])
PATH = ":".join(NEW_PATH_LIST)
else:
PYTHONPATH = os.environ.get('PYTHONPATH', '') + ":" +\
ROBOT_TEST_BASE_DIR_PATH + "lib"
PATH = os.environ.get('PATH', '') + ":" + ROBOT_TEST_BASE_DIR_PATH +\
"bin" + ":" + OPENBMCTOOL_DIR_PATH.rstrip('/')
os.environ['PYTHONPATH'] = PYTHONPATH
os.environ['PATH'] = PATH
gp.dprint_vars(PATH, PYTHONPATH)
os.environ['FFDC_DIR_PATH_STYLE'] = os.environ.get('FFDC_DIR_PATH_STYLE',
'1')
gp.qpissuing(robot_cmd_buf, test_mode)
if test_mode:
os.environ["PATH"] = os.environ.get("SAVED_PATH", "")
os.environ["PYTHONPATH"] = os.environ.get("SAVED_PYTHONPATH", "")
return True
if quiet:
DEVNULL = open(os.devnull, 'wb')
stdout = DEVNULL
else:
stdout = None
sub_proc = subprocess.Popen(robot_cmd_buf, stdout=stdout, shell=True)
sub_proc.communicate()
shell_rc = sub_proc.returncode
os.environ["PATH"] = os.environ.get("SAVED_PATH", "")
os.environ["PYTHONPATH"] = os.environ.get("SAVED_PYTHONPATH", "")
gcr_last_robot_rc = shell_rc
process_robot_output_files()
if shell_rc != 0:
gp.print_var(shell_rc, gp.hexa())
return False
return True
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 get_os_state(os_host="",
os_username="",
os_password="",
req_states=default_os_req_states,
os_up=True,
quiet=None):
r"""
Get component states for the operating system such as ping, login,
etc, put them into a dictionary and return them to the caller.
Note that all substate values are strings.
Description of argument(s):
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}.
req_states This is a list of states whose values are being requested by
the caller.
os_up If the caller knows that the os can't possibly be up, it can
improve performance by passing os_up=False. This function
will then simply return default values for all requested os
sub states.
quiet Indicates whether status details (e.g. curl commands) should
be written to the console.
Defaults to either global value of ${QUIET} or to 1.
"""
quiet = int(gp.get_var_value(quiet, 0))
# Set parm defaults where necessary and validate all parms.
if os_host == "":
os_host = BuiltIn().get_variable_value("${OS_HOST}")
error_message = gv.valid_value(os_host, invalid_values=[None, ""])
if error_message != "":
BuiltIn().fail(gp.sprint_error(error_message))
if os_username == "":
os_username = BuiltIn().get_variable_value("${OS_USERNAME}")
error_message = gv.valid_value(os_username, invalid_values=[None, ""])
if error_message != "":
BuiltIn().fail(gp.sprint_error(error_message))
if os_password == "":
os_password = BuiltIn().get_variable_value("${OS_PASSWORD}")
error_message = gv.valid_value(os_password, invalid_values=[None, ""])
if error_message != "":
BuiltIn().fail(gp.sprint_error(error_message))
invalid_req_states = [sub_state for sub_state in req_states
if sub_state not in valid_os_req_states]
if len(invalid_req_states) > 0:
error_message = "The following req_states are not supported:\n" +\
gp.sprint_var(invalid_req_states)
BuiltIn().fail(gp.sprint_error(error_message))
# Initialize all substate values supported by this function.
os_ping = 0
os_login = 0
os_run_cmd = 0
if os_up:
if 'os_ping' in req_states:
# See if the OS pings.
rc, out_buf = gc.shell_cmd("ping -c 1 -w 2 " + os_host,
print_output=0, show_err=0,
ignore_err=1)
if rc == 0:
os_ping = 1
# Programming note: All attributes which do not require an ssh login
# should have been processed by this point.
master_req_login = ['os_login', 'os_run_cmd']
req_login = [sub_state for sub_state in req_states if sub_state in
master_req_login]
must_login = (len(req_login) > 0)
if must_login:
output, stderr, rc = bsu.os_execute_command("uptime", quiet=quiet,
ignore_err=1,
time_out=20)
if rc == 0:
os_login = 1
os_run_cmd = 1
else:
gp.dprint_vars(output, stderr)
gp.dprint_vars(rc, 1)
os_state = DotDict()
for sub_state in req_states:
cmd_buf = "os_state['" + sub_state + "'] = str(" + sub_state + ")"
exec(cmd_buf)
return os_state
def init_robot_test_base_dir_path():
r"""
Initialize and validate the environment variable, ROBOT_TEST_BASE_DIR_PATH
and set corresponding global variable ROBOT_TEST_RUNNING_FROM_SB.
If ROBOT_TEST_BASE_DIR_PATH is already set, this function will merely
validate it. This function will also set environment variable
ROBOT_TEST_RUNNING_FROM_SB when ROBOT_TEST_BASE_DIR_PATH is not pre-set.
"""
# ROBOT_TEST_BASE_DIR_PATH will be set as follows:
# This function will determine whether we are running in a user sandbox
# or from a standard apolloxxx environment.
# - User sandbox:
# If there is a <developer's home dir>/git/openbmc-test-automation/,
# ROBOT_TEST_BASE_DIR_PATH will be set to that path. Otherwise, we set it
# to <program dir path>/git/openbmc-test-automation/
# - Not in user sandbox:
# ROBOT_TEST_BASE_DIR_PATH will be set to <program dir
# path>/git/openbmc-test-automation/
ROBOT_TEST_BASE_DIR_PATH = os.environ.get('ROBOT_TEST_BASE_DIR_PATH', "")
ROBOT_TEST_RUNNING_FROM_SB = \
int(os.environ.get('ROBOT_TEST_RUNNING_FROM_SB', "0"))
if ROBOT_TEST_BASE_DIR_PATH == "":
# ROBOT_TEST_BASE_DIR_PATH was not set by user/caller.
AUTOIPL_VERSION = os.environ.get('AUTOIPL_VERSION', '')
if AUTOIPL_VERSION == "":
ROBOT_TEST_BASE_DIR_PATH = base_path
else:
suffix = "git/openbmc-test-automation/"
# Determine whether we're running out of a developer sandbox or
# simply out of an apolloxxx/bin path.
shell_rc, out_buf = gc.shell_cmd('dirname $(which gen_print.py)',
quiet=(not debug), print_output=0)
executable_base_dir_path = os.path.realpath(out_buf.rstrip()) + "/"
apollo_dir_path = os.environ['AUTO_BASE_PATH'] + AUTOIPL_VERSION +\
"/bin/"
developer_home_dir_path = re.sub('/sandbox.*', '',
executable_base_dir_path)
developer_home_dir_path = \
gm.add_trailing_slash(developer_home_dir_path)
gp.dprint_vars(executable_base_dir_path, developer_home_dir_path,
apollo_dir_path)
ROBOT_TEST_RUNNING_FROM_SB = 0
if executable_base_dir_path != apollo_dir_path:
ROBOT_TEST_RUNNING_FROM_SB = 1
gp.dprint_vars(ROBOT_TEST_RUNNING_FROM_SB)
ROBOT_TEST_BASE_DIR_PATH = developer_home_dir_path + suffix
if not os.path.isdir(ROBOT_TEST_BASE_DIR_PATH):
gp.dprint_timen("NOTE: Sandbox directory "
+ ROBOT_TEST_BASE_DIR_PATH + " does not"
+ " exist.")
# Fall back to the apollo dir path.
ROBOT_TEST_BASE_DIR_PATH = apollo_dir_path + suffix
else:
# Use to the apollo dir path.
ROBOT_TEST_BASE_DIR_PATH = apollo_dir_path + suffix
if not gv.valid_value(ROBOT_TEST_BASE_DIR_PATH):
return False
gp.dprint_vars(ROBOT_TEST_RUNNING_FROM_SB, ROBOT_TEST_BASE_DIR_PATH)
if not gv.valid_dir_path(ROBOT_TEST_BASE_DIR_PATH):
return False
ROBOT_TEST_BASE_DIR_PATH = gm.add_trailing_slash(ROBOT_TEST_BASE_DIR_PATH)
gm.set_mod_global(ROBOT_TEST_BASE_DIR_PATH)
os.environ['ROBOT_TEST_BASE_DIR_PATH'] = ROBOT_TEST_BASE_DIR_PATH
gm.set_mod_global(ROBOT_TEST_RUNNING_FROM_SB)
os.environ['ROBOT_TEST_RUNNING_FROM_SB'] = str(ROBOT_TEST_RUNNING_FROM_SB)
def rprocess_plug_in_packages(plug_in_packages_list=None,
call_point="setup",
shell_rc="0x00000000",
stop_on_plug_in_failure=1,
stop_on_non_zero_rc=0,
release_type="obmc",
quiet=None,
debug=None,
return_history=False):
r"""
Call the external process_plug_in_packages.py to process the plug-in packages. Return the following:
rc The return code - 0 = PASS, 1 = FAIL.
shell_rc The shell return code returned by process_plug_in_packages.py.
failed_plug_in_name The failed plug in name (if any).
Description of arguments:
plug_in_packages_list A python list of plug-in directory paths.
call_point The call point program to be called for each plug-in package (e.g.
post_boot). This name should not include the "cp_" prefix.
shell_rc The user may supply a value other than zero to indicate an acceptable
non-zero return code. For example, if this value equals 0x00000200, it
means that for each plug-in call point that runs, a 0x00000200 will not
be counted as a failure.
stop_on_plug_in_failure If this parameter is set to 1, this program will stop and return non-zero
if the call point program from any plug-in directory fails. Conversely,
if it is set to false, this program will run the call point program from
each and every plug-in directory regardless of their return values.
Typical example cases where you'd want to run all plug-in call points
regardless of success or failure would be "cleanup" or "ffdc" call points.
stop_on_non_zero_rc If this parm is set to 1 and a plug-in call point program returns a valid
non-zero return code (see "shell_rc" parm above), this program will stop
processing and return 0 (success). Since this constitutes a successful
exit, this would normally be used where the caller wishes to stop
processing if one of the plug-in directory call point programs returns a
special value indicating that some special case has been found. An
example might be in calling some kind of "check_errl" call point program.
Such a call point program might return a 2 (i.e. 0x00000200) to indicate
that a given error log entry was found in an "ignore" list and is
therefore to be ignored. That being the case, no other "check_errl" call
point program would need to be called.
release_type The type of release being tested (e.g. "obmc", "op", "fips"). This
influences which integrated plug-ins are selected.
quiet If quiet is set to 1, this function will NOT write status messages to
stdout. This will default to the global quiet program parm or to 0.
debug If this parameter is set to 1, this function will print additional debug
information. This is mainly to be used by the developer of this
function. This will default to the global quiet program parm or to 0.
return_history In addition to rc, shell_rc and failed_plug_in_name, return a list
containing historical output that looks like the following:
history:
history[0]: #(CDT) 2018/10/30 12:25:49 - Running OBMC_Sample/cp_post_stack
"""
rc = 0
plug_in_packages_list = gp.get_var_value(plug_in_packages_list, [])
# If there are no plug-in packages to process, return successfully.
if len(plug_in_packages_list) == 0:
if return_history:
return 0, 0, "", []
else:
return 0, 0, ""
quiet = int(gp.get_var_value(quiet, 0))
debug = int(gp.get_var_value(debug, 0))
# Create string from list.
plug_in_dir_paths = ':'.join(plug_in_packages_list)
temp = tempfile.NamedTemporaryFile()
temp_file_path = temp.name
temp2 = tempfile.NamedTemporaryFile()
temp_properties_file_path = temp2.name
if debug:
os.environ["PERF_TRACE"] = "1"
debug_string = " --quiet=0"
else:
debug_string = ""
loc_shell_rc = 0
sub_cmd_buf = "process_plug_in_packages.py" + debug_string +\
" --call_point=" + call_point + " --allow_shell_rc=" +\
str(shell_rc) + " --stop_on_plug_in_failure=" +\
str(stop_on_plug_in_failure) + " --stop_on_non_zero_rc=" +\
str(stop_on_non_zero_rc) + " " + plug_in_dir_paths
if quiet:
cmd_buf = sub_cmd_buf + " > " + temp_file_path + " 2>&1"
else:
cmd_buf = "set -o pipefail ; " + sub_cmd_buf + " 2>&1 | tee " +\
temp_file_path
if debug:
gp.print_issuing(cmd_buf)
else:
gp.print_timen("Processing " + call_point +
" call point programs.")
sub_proc = subprocess.Popen(cmd_buf, shell=True, executable='/bin/bash')
sub_proc.communicate()
proc_plug_pkg_rc = sub_proc.returncode
if return_history:
# Get the "Running" statements from the output.
regex = " Running [^/]+/cp_"
cmd_buf = "egrep '" + regex + "' " + temp_file_path
_, history = gc.shell_cmd(cmd_buf,
quiet=(not debug),
print_output=0,
show_err=0,
ignore_err=1)
history = [x + "\n" for x in filter(None, history.split("\n"))]
else:
history = []
# As process_plug_in_packages.py help text states, it will print the values of failed_plug_in_name and
# shell_rc in the following format:
# failed_plug_in_name: <failed plug-in value, if any>
# shell_rc: <shell return code value of last call point program>
# We want to obtain those values from the output. To make the task simpler, we'll start by grepping the
# output for lines that might fit such a format:
# A valid bash variable against the left margin followed by...
# - A colon followed by...
# - Zero or more spaces
bash_var_regex = "[_[:alpha:]][_[:alnum:]]*"
regex = "^" + bash_var_regex + ":[ ]*"
cmd_buf = "egrep '" + regex + "' " + temp_file_path + " > " +\
temp_properties_file_path
gp.dprint_issuing(cmd_buf)
grep_rc = os.system(cmd_buf)
# Next we call my_parm_file to create a properties dictionary.
properties = gm.my_parm_file(temp_properties_file_path)
# Finally, we access the 2 values that we need.
shell_rc = int(properties.get('shell_rc', '0x0000000000000000'), 16)
failed_plug_in_name = properties.get('failed_plug_in_name', '')
if proc_plug_pkg_rc != 0:
if quiet:
os.system("cat " + temp_file_path + " >&2")
if grep_rc != 0:
gp.print_var(grep_rc, gp.hexa())
gp.print_var(proc_plug_pkg_rc, gp.hexa())
gp.print_timen("Re-cap of plug-in failures:")
gc.cmd_fnc_u("egrep -A 1 '^failed_plug_in_name:[ ]+' " +
temp_properties_file_path + " | egrep -v '^\\--'",
quiet=1,
show_err=0)
rc = 1
if return_history:
return rc, shell_rc, failed_plug_in_name, history
else:
return rc, shell_rc, failed_plug_in_name
def get_state(openbmc_host="",
openbmc_username="",
openbmc_password="",
os_host="",
os_username="",
os_password="",
req_states=default_req_states,
quiet=None):
r"""
Get component states such as chassis state, bmc state, etc, put them into a
dictionary and return them to the caller.
Note that all substate values are strings.
Note: If elapsed_boot_time is included in req_states, it is the caller's
duty to call set_start_boot_seconds() in order to set global
start_boot_seconds. elapsed_boot_time is the current time minus
start_boot_seconds.
Description of argument(s):
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}.
req_states This is a list of states whose values are being requested
by the caller.
quiet Indicates whether status details (e.g. curl commands)
should be written to the console.
Defaults to either global value of ${QUIET} or to 1.
"""
quiet = int(gp.get_var_value(quiet, 0))
# Set parm defaults where necessary and validate all parms.
if openbmc_host == "":
openbmc_host = BuiltIn().get_variable_value("${OPENBMC_HOST}")
error_message = gv.valid_value(openbmc_host, invalid_values=[None, ""])
if error_message != "":
BuiltIn().fail(gp.sprint_error(error_message))
if openbmc_username == "":
openbmc_username = BuiltIn().get_variable_value("${OPENBMC_USERNAME}")
error_message = gv.valid_value(openbmc_username, invalid_values=[None, ""])
if error_message != "":
BuiltIn().fail(gp.sprint_error(error_message))
if openbmc_password == "":
openbmc_password = BuiltIn().get_variable_value("${OPENBMC_PASSWORD}")
error_message = gv.valid_value(openbmc_password, invalid_values=[None, ""])
if error_message != "":
BuiltIn().fail(gp.sprint_error(error_message))
# NOTE: OS parms are optional.
if os_host == "":
os_host = BuiltIn().get_variable_value("${OS_HOST}")
if os_host is None:
os_host = ""
if os_username is "":
os_username = BuiltIn().get_variable_value("${OS_USERNAME}")
if os_username is None:
os_username = ""
if os_password is "":
os_password = BuiltIn().get_variable_value("${OS_PASSWORD}")
if os_password is None:
os_password = ""
invalid_req_states = [sub_state for sub_state in req_states
if sub_state not in valid_req_states]
if len(invalid_req_states) > 0:
error_message = "The following req_states are not supported:\n" +\
gp.sprint_var(invalid_req_states)
BuiltIn().fail(gp.sprint_error(error_message))
# Initialize all substate values supported by this function.
ping = 0
packet_loss = ''
uptime = ''
epoch_seconds = ''
elapsed_boot_time = ''
rest = ''
chassis = ''
requested_chassis = ''
bmc = ''
requested_bmc = ''
boot_progress = ''
operating_system = ''
host = ''
requested_host = ''
attempts_left = ''
# Get the component states.
if 'ping' in req_states:
# See if the OS pings.
rc, out_buf = gc.shell_cmd("ping -c 1 -w 2 " + openbmc_host,
print_output=0, show_err=0,
ignore_err=1)
if rc == 0:
ping = 1
if 'packet_loss' in req_states:
# See if the OS pings.
cmd_buf = "ping -c 5 -w 5 " + openbmc_host +\
" | egrep 'packet loss' | sed -re 's/.* ([0-9]+)%.*/\\1/g'"
rc, out_buf = gc.shell_cmd(cmd_buf,
print_output=0, show_err=0,
ignore_err=1)
if rc == 0:
packet_loss = out_buf.rstrip("\n")
if 'uptime' in req_states:
# Sometimes reading uptime results in a blank value. Call with
# wait_until_keyword_succeeds to ensure a non-blank value is obtained.
remote_cmd_buf = "read uptime filler 2>/dev/null < /proc/uptime" +\
" && [ ! -z \"${uptime}\" ] && echo ${uptime}"
cmd_buf = ["BMC Execute Command",
re.sub('\\$', '\\$', remote_cmd_buf), 'quiet=1',
'test_mode=0']
gp.qprint_issuing(cmd_buf, 0)
gp.qprint_issuing(remote_cmd_buf, 0)
try:
stdout, stderr, rc =\
BuiltIn().wait_until_keyword_succeeds("10 sec", "0 sec",
*cmd_buf)
if rc == 0 and stderr == "":
uptime = stdout
except AssertionError as my_assertion_error:
pass
if 'epoch_seconds' in req_states or 'elapsed_boot_time' in req_states:
date_cmd_buf = "date -u +%s"
if USE_BMC_EPOCH_TIME:
cmd_buf = ["BMC Execute Command", date_cmd_buf, 'quiet=${1}']
if not quiet:
gp.print_issuing(cmd_buf)
status, ret_values = \
BuiltIn().run_keyword_and_ignore_error(*cmd_buf)
if status == "PASS":
stdout, stderr, rc = ret_values
if rc == 0 and stderr == "":
epoch_seconds = stdout.rstrip("\n")
else:
shell_rc, out_buf = gc.cmd_fnc_u(date_cmd_buf,
quiet=quiet,
print_output=0)
if shell_rc == 0:
epoch_seconds = out_buf.rstrip("\n")
if 'elapsed_boot_time' in req_states:
global start_boot_seconds
elapsed_boot_time = int(epoch_seconds) - start_boot_seconds
master_req_rest = ['rest', 'host', 'requested_host', 'operating_system',
'attempts_left', 'boot_progress', 'chassis',
'requested_chassis' 'bmc' 'requested_bmc']
req_rest = [sub_state for sub_state in req_states if sub_state in
master_req_rest]
need_rest = (len(req_rest) > 0)
state = DotDict()
if need_rest:
cmd_buf = ["Read Properties", SYSTEM_STATE_URI + "enumerate",
"quiet=${" + str(quiet) + "}"]
gp.dprint_issuing(cmd_buf)
status, ret_values = \
BuiltIn().run_keyword_and_ignore_error(*cmd_buf)
if status == "PASS":
state['rest'] = '1'
else:
state['rest'] = '0'
if int(state['rest']):
for url_path in ret_values:
for attr_name in ret_values[url_path]:
# Create a state key value based on the attr_name.
try:
ret_values[url_path][attr_name] = \
re.sub(r'.*\.', "",
ret_values[url_path][attr_name])
except TypeError:
pass
# Do some key name manipulations.
new_attr_name = re.sub(r'^Current|(State|Transition)$',
"", attr_name)
new_attr_name = re.sub(r'BMC', r'Bmc', new_attr_name)
new_attr_name = re.sub(r'([A-Z][a-z])', r'_\1',
new_attr_name)
new_attr_name = new_attr_name.lower().lstrip("_")
new_attr_name = re.sub(r'power', r'chassis', new_attr_name)
if new_attr_name in req_states:
state[new_attr_name] = ret_values[url_path][attr_name]
for sub_state in req_states:
if sub_state in state:
continue
if sub_state.startswith("os_"):
# We pass "os_" requests on to get_os_state.
continue
cmd_buf = "state['" + sub_state + "'] = str(" + sub_state + ")"
exec(cmd_buf)
if os_host == "":
# The caller has not specified an os_host so as far as we're concerned,
# it doesn't exist.
return state
os_req_states = [sub_state for sub_state in req_states
if sub_state.startswith('os_')]
if len(os_req_states) > 0:
# The caller has specified an os_host and they have requested
# information on os substates.
# Based on the information gathered on bmc, we'll try to make a
# determination of whether the os is even up. We'll pass the result
# of that assessment to get_os_state to enhance performance.
os_up_match = DotDict()
for sub_state in master_os_up_match:
if sub_state in req_states:
os_up_match[sub_state] = master_os_up_match[sub_state]
os_up = compare_states(state, os_up_match)
os_state = get_os_state(os_host=os_host,
os_username=os_username,
os_password=os_password,
req_states=os_req_states,
os_up=os_up,
quiet=quiet)
# Append os_state dictionary to ours.
state.update(os_state)
return state
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))
