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 + "\""
if int(quiet) != 1:
grp.rpissuing(cmd_buf)
rc, out_buf = commands.getstatusoutput(cmd_buf)
if rc != 0:
message = gp.sprint_varx("rc", rc, 1) + out_buf
grp.rprintn(out_buf, 'STDERR')
BuiltIn().fail(
gp.sprint_error("Validate plug ins call failed. See" +
" stderr text for details.\n"))
plug_in_packages_list = out_buf.split("\n")
if len(plug_in_packages_list) == 1 and plug_in_packages_list[0] == "":
return []
return plug_in_packages_list
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 + "\""
if int(quiet) != 1:
grp.rpissuing(cmd_buf)
rc, out_buf = commands.getstatusoutput(cmd_buf)
if rc != 0:
message = gp.sprint_varx("rc", rc, 1) + out_buf
grp.rprintn(out_buf, 'STDERR')
BuiltIn().fail(gp.sprint_error("Validate plug ins call failed. See" +
" stderr text for details.\n"))
plug_in_packages_list = out_buf.split("\n")
if len(plug_in_packages_list) == 1 and plug_in_packages_list[0] == "":
return []
return plug_in_packages_list
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.
Description of arguments:
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.svalid_value(openbmc_host,
var_name="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.svalid_value(openbmc_username,
var_name="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.svalid_value(openbmc_password,
var_name="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 = ''
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.
cmd_buf = "ping -c 1 -w 2 " + openbmc_host
if not quiet:
gp.pissuing(cmd_buf)
rc, out_buf = commands.getstatusoutput(cmd_buf)
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'"
if not quiet:
gp.pissuing(cmd_buf)
rc, out_buf = commands.getstatusoutput(cmd_buf)
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'
]
if not quiet:
grp.rpissuing_keyword(cmd_buf)
grp.rpissuing(remote_cmd_buf)
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:
date_cmd_buf = "date -u +%s"
if USE_BMC_EPOCH_TIME:
cmd_buf = ["BMC Execute Command", date_cmd_buf, 'quiet=${1}']
if not quiet:
grp.rpissuing_keyword(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")
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) + "}"
]
grp.rdpissuing_keyword(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.
if isinstance(ret_values[url_path][attr_name], unicode):
ret_values[url_path][attr_name] = \
re.sub(r'.*\.', "",
ret_values[url_path][attr_name])
# 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 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):
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.
"""
rc = 0
if plug_in_packages_list is None:
plug_in_packages_list = BuiltIn().get_variable_value(
"${plug_in_packages_list}")
# If there are no plug-in packages to process, return successfully.
if len(plug_in_packages_list) == 0:
return 0, 0, ""
if quiet is None:
try:
quiet = int(BuiltIn().get_variable_value("${quiet}"))
except TypeError:
quiet = 0
if debug is None:
try:
debug = int(BuiltIn().get_variable_value("${debug}"))
except TypeError:
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 int(debug) == 1:
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 int(quiet) == 1:
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 int(debug) == 1:
grp.rpissuing(cmd_buf)
else:
grp.rprint_timen("Processing " + call_point +
" call point programs.")
proc_plug_pkg_rc = subprocess.call(cmd_buf,
shell=True,
executable='/bin/bash')
# 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
# - A colon
# - Zero or more spaces
bash_var_regex = "[_[:alpha:]][_[:alnum:]]*"
regex = "^" + bash_var_regex + ":[ ]*"
cmd_buf = "egrep '" + regex + "' " + temp_file_path + " > " +\
temp_properties_file_path
if int(debug) == 1:
grp.rpissuing(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.
try:
shell_rc = int(properties['shell_rc'], 16)
except KeyError:
shell_rc = 0
try:
failed_plug_in_name = properties['failed_plug_in_name']
except KeyError:
failed_plug_in_name = ""
if proc_plug_pkg_rc != 0:
hex = 1
grp.rprint_error("Call to process_plug_in_packages failed.\n")
grp.rprint_varx("grep_rc", grep_rc, hex)
grp.rprint_varx("proc_plug_pkg_rc", proc_plug_pkg_rc, hex)
# Show all of the failed plug in names and shell_rcs.
gc.cmd_fnc_u("egrep -A 1 '^failed_plug_in_name:[ ]+' " +
temp_properties_file_path,
quiet=1,
show_err=0)
rc = 1
return rc, shell_rc, failed_plug_in_name
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):
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.
"""
rc = 0
if plug_in_packages_list is None:
plug_in_packages_list = BuiltIn().get_variable_value(
"${plug_in_packages_list}")
# If there are no plug-in packages to process, return successfully.
if len(plug_in_packages_list) == 0:
return 0, 0, ""
if quiet is None:
try:
quiet = int(BuiltIn().get_variable_value("${quiet}"))
except TypeError:
quiet = 0
if debug is None:
try:
debug = int(BuiltIn().get_variable_value("${debug}"))
except TypeError:
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 int(debug) == 1:
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 + " --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 int(quiet) == 1:
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 int(debug) == 1:
grp.rpissuing(cmd_buf)
else:
grp.rprint_timen("Processing " + call_point +
" call point programs.")
proc_plug_pkg_rc = subprocess.call(cmd_buf, shell=True)
# 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
# - A colon
# - Zero or more spaces
bash_var_regex = "[_[:alpha:]][_[:alnum:]]*"
regex = "^" + bash_var_regex + ":[ ]*"
cmd_buf = "egrep '" + regex + "' " + temp_file_path + " > " +\
temp_properties_file_path
if int(debug) == 1:
grp.rpissuing(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.
try:
shell_rc = int(properties['shell_rc'], 16)
except KeyError:
shell_rc = 0
try:
failed_plug_in_name = properties['failed_plug_in_name']
except KeyError:
failed_plug_in_name = ""
if proc_plug_pkg_rc != 0:
hex = 1
grp.rprint_error("Call to process_plug_in_packages failed.\n")
grp.rprint_varx("grep_rc", grep_rc, hex)
grp.rprint_varx("proc_plug_pkg_rc", proc_plug_pkg_rc, hex)
# Show all of the failed plug in names and shell_rcs.
gc.cmd_fnc_u("egrep -A 1 '^failed_plug_in_name:[ ]+' " +
temp_properties_file_path, quiet=1, show_err=0)
rc = 1
return rc, shell_rc, failed_plug_in_name