1#!/usr/bin/env python3 2 3r""" 4This module contains functions having to do with machine state: get_state, 5check_state, wait_state, etc. 6 7The 'State' is a composite of many pieces of data. Therefore, the functions 8in this module define state as an ordered dictionary. Here is an example of 9some test output showing machine state: 10 11default_state: 12 default_state[chassis]: On 13 default_state[boot_progress]: OSStart 14 default_state[operating_system]: BootComplete 15 default_state[host]: Running 16 default_state[os_ping]: 1 17 default_state[os_login]: 1 18 default_state[os_run_cmd]: 1 19 20Different users may very well have different needs when inquiring about 21state. Support for new pieces of state information may be added to this 22module as needed. 23 24By using the wait_state function, a caller can start a boot and then wait for 25a precisely defined state to indicate that the boot has succeeded. If 26the boot fails, they can see exactly why by looking at the current state as 27compared with the expected state. 28""" 29 30import gen_print as gp 31import gen_valid as gv 32import gen_robot_utils as gru 33import gen_cmd as gc 34import bmc_ssh_utils as bsu 35 36from robot.libraries.BuiltIn import BuiltIn 37from robot.utils import DotDict 38 39import re 40import os 41import sys 42import imp 43 44 45# NOTE: Avoid importing utils.robot because utils.robot imports state.py 46# (indirectly) which will cause failures. 47gru.my_import_resource("rest_client.robot") 48 49base_path = os.path.dirname(os.path.dirname( 50 imp.find_module("gen_robot_print")[1])) + os.sep 51sys.path.append(base_path + "data/") 52 53# Previously, I had this coded: 54# import variables as var 55# However, we ran into a problem where a robot program did this... 56# Variables ../../lib/ras/variables.py 57# Prior to doing this... 58# Library ../lib/state.py 59 60# This caused the wrong variables.py file to be selected. Attempts to fix this 61# have failed so far. For the moment, we will hard-code the value we need from 62# the file. 63 64SYSTEM_STATE_URI = "/xyz/openbmc_project/state/" 65 66# The BMC code has recently been changed as far as what states are defined and 67# what the state values can be. This module now has a means of processing both 68# the old style state (i.e. OBMC_STATES_VERSION = 0) and the new style (i.e. 69# OBMC_STATES_VERSION = 1). 70# The caller can set environment variable OBMC_STATES_VERSION to dictate 71# whether we're processing old or new style states. If OBMC_STATES_VERSION is 72# not set it will default to 1. 73 74# As of the present moment, OBMC_STATES_VERSION of 0 is for cold that is so old 75# that it is no longer worthwhile to maintain. The OBMC_STATES_VERSION 0 code 76# is being removed but the OBMC_STATES_VERSION value will stay for now in the 77# event that it is needed in the future. 78 79OBMC_STATES_VERSION = int(os.environ.get('OBMC_STATES_VERSION', 1)) 80 81redfish_support_trans_state = int(os.environ.get('REDFISH_SUPPORT_TRANS_STATE', 0)) or \ 82 int(BuiltIn().get_variable_value("${REDFISH_SUPPORT_TRANS_STATE}", default=0)) 83 84platform_arch_type = os.environ.get('PLATFORM_ARCH_TYPE', '') or \ 85 BuiltIn().get_variable_value("${PLATFORM_ARCH_TYPE}", default="power") 86 87# valid_os_req_states and default_os_req_states are used by the os_get_state 88# function. 89# valid_os_req_states is a list of state information supported by the 90# get_os_state function. 91valid_os_req_states = ['os_ping', 92 'os_login', 93 'os_run_cmd'] 94 95# When a user calls get_os_state w/o specifying req_states, 96# default_os_req_states is used as its value. 97default_os_req_states = ['os_ping', 98 'os_login', 99 'os_run_cmd'] 100 101# Presently, some BMCs appear to not keep time very well. This environment 102# variable directs the get_state function to use either the BMC's epoch time 103# or the local epoch time. 104USE_BMC_EPOCH_TIME = int(os.environ.get('USE_BMC_EPOCH_TIME', 0)) 105 106# Useful state constant definition(s). 107if not redfish_support_trans_state: 108 # When a user calls get_state w/o specifying req_states, default_req_states 109 # is used as its value. 110 default_req_states = ['rest', 111 'chassis', 112 'bmc', 113 'boot_progress', 114 'operating_system', 115 'host', 116 'os_ping', 117 'os_login', 118 'os_run_cmd'] 119 120 # valid_req_states is a list of sub states supported by the get_state function. 121 # valid_req_states, default_req_states and master_os_up_match are used by the 122 # get_state function. 123 124 valid_req_states = ['ping', 125 'packet_loss', 126 'uptime', 127 'epoch_seconds', 128 'elapsed_boot_time', 129 'rest', 130 'chassis', 131 'requested_chassis', 132 'bmc', 133 'requested_bmc', 134 'boot_progress', 135 'operating_system', 136 'host', 137 'requested_host', 138 'attempts_left', 139 'os_ping', 140 'os_login', 141 'os_run_cmd'] 142 143 # default_state is an initial value which may be of use to callers. 144 default_state = DotDict([('rest', '1'), 145 ('chassis', 'On'), 146 ('bmc', 'Ready'), 147 ('boot_progress', 'OSStart'), 148 ('operating_system', 'BootComplete'), 149 ('host', 'Running'), 150 ('os_ping', '1'), 151 ('os_login', '1'), 152 ('os_run_cmd', '1')]) 153 154 # A match state for checking that the system is at "standby". 155 standby_match_state = DotDict([('rest', '^1$'), 156 ('chassis', '^Off$'), 157 ('bmc', '^Ready$'), 158 ('boot_progress', '^Off|Unspecified$'), 159 ('operating_system', '^Inactive$'), 160 ('host', '^Off$')]) 161 162 # A match state for checking that the system is at "os running". 163 os_running_match_state = DotDict([('chassis', '^On$'), 164 ('bmc', '^Ready$'), 165 ('boot_progress', 166 'FW Progress, Starting OS|OSStart'), 167 ('operating_system', 'BootComplete'), 168 ('host', '^Running$'), 169 ('os_ping', '^1$'), 170 ('os_login', '^1$'), 171 ('os_run_cmd', '^1$')]) 172 173 # A master dictionary to determine whether the os may be up. 174 master_os_up_match = DotDict([('chassis', '^On$'), 175 ('bmc', '^Ready$'), 176 ('boot_progress', 177 'FW Progress, Starting OS|OSStart'), 178 ('operating_system', 'BootComplete'), 179 ('host', '^Running|Quiesced$')]) 180 181 invalid_state_match = DotDict([('rest', '^$'), 182 ('chassis', '^$'), 183 ('bmc', '^$'), 184 ('boot_progress', '^$'), 185 ('operating_system', '^$'), 186 ('host', '^$')]) 187else: 188 # When a user calls get_state w/o specifying req_states, default_req_states 189 # is used as its value. 190 default_req_states = ['redfish', 191 'chassis', 192 'bmc', 193 'boot_progress', 194 'host', 195 'os_ping', 196 'os_login', 197 'os_run_cmd'] 198 199 # valid_req_states is a list of sub states supported by the get_state function. 200 # valid_req_states, default_req_states and master_os_up_match are used by the 201 # get_state function. 202 203 valid_req_states = ['ping', 204 'packet_loss', 205 'uptime', 206 'epoch_seconds', 207 'elapsed_boot_time', 208 'redfish', 209 'chassis', 210 'requested_chassis', 211 'bmc', 212 'requested_bmc', 213 'boot_progress', 214 'host', 215 'requested_host', 216 'attempts_left', 217 'os_ping', 218 'os_login', 219 'os_run_cmd'] 220 221 # default_state is an initial value which may be of use to callers. 222 default_state = DotDict([('redfish', '1'), 223 ('chassis', 'On'), 224 ('bmc', 'Enabled'), 225 ('boot_progress', 226 'SystemHardwareInitializationComplete|OSBootStarted|OSRunning'), 227 ('host', 'Enabled'), 228 ('os_ping', '1'), 229 ('os_login', '1'), 230 ('os_run_cmd', '1')]) 231 232 # A match state for checking that the system is at "standby". 233 standby_match_state = DotDict([('redfish', '^1$'), 234 ('chassis', '^Off$'), 235 ('bmc', '^Enabled$'), 236 ('boot_progress', '^None$'), 237 ('host', '^Disabled$')]) 238 239 # A match state for checking that the system is at "os running". 240 os_running_match_state = DotDict([('chassis', '^On$'), 241 ('bmc', '^Enabled$'), 242 ('boot_progress', 243 'SystemHardwareInitializationComplete|OSBootStarted|OSRunning'), 244 ('host', '^Enabled$'), 245 ('os_ping', '^1$'), 246 ('os_login', '^1$'), 247 ('os_run_cmd', '^1$')]) 248 249 # A master dictionary to determine whether the os may be up. 250 master_os_up_match = DotDict([('chassis', '^On$'), 251 ('bmc', '^Enabled$'), 252 ('boot_progress', 253 'SystemHardwareInitializationComplete|OSBootStarted|OSRunning'), 254 ('host', '^Enabled$')]) 255 256 invalid_state_match = DotDict([('redfish', '^$'), 257 ('chassis', '^$'), 258 ('bmc', '^$'), 259 ('boot_progress', '^$'), 260 ('host', '^$')]) 261 262# Filter the states based on platform type. 263if platform_arch_type == "x86": 264 265 if not redfish_support_trans_state: 266 default_req_states.remove("operating_system") 267 valid_req_states.remove("operating_system") 268 del default_state["operating_system"] 269 del standby_match_state["operating_system"] 270 del os_running_match_state["operating_system"] 271 del master_os_up_match["operating_system"] 272 del invalid_state_match["operating_system"] 273 274 default_req_states.remove("boot_progress") 275 valid_req_states.remove("boot_progress") 276 del default_state["boot_progress"] 277 del standby_match_state["boot_progress"] 278 del os_running_match_state["boot_progress"] 279 del master_os_up_match["boot_progress"] 280 del invalid_state_match["boot_progress"] 281 282 283def return_state_constant(state_name='default_state'): 284 r""" 285 Return the named state dictionary constant. 286 """ 287 288 return eval(state_name) 289 290 291def anchor_state(state): 292 r""" 293 Add regular expression anchors ("^" and "$") to the beginning and end of 294 each item in the state dictionary passed in. Return the resulting 295 dictionary. 296 297 Description of argument(s): 298 state A dictionary such as the one returned by the get_state() 299 function. 300 """ 301 302 anchored_state = state.copy() 303 for key in anchored_state.keys(): 304 anchored_state[key] = "^" + str(anchored_state[key]) + "$" 305 306 return anchored_state 307 308 309def strip_anchor_state(state): 310 r""" 311 Strip regular expression anchors ("^" and "$") from the beginning and end 312 of each item in the state dictionary passed in. Return the resulting 313 dictionary. 314 315 Description of argument(s): 316 state A dictionary such as the one returned by the get_state() 317 function. 318 """ 319 320 stripped_state = state.copy() 321 for key in stripped_state.keys(): 322 stripped_state[key] = stripped_state[key].strip("^$") 323 324 return stripped_state 325 326 327def expressions_key(): 328 r""" 329 Return expressions key constant. 330 """ 331 return '<expressions>' 332 333 334def compare_states(state, 335 match_state, 336 match_type='and'): 337 r""" 338 Compare 2 state dictionaries. Return True if they match and False if they 339 don't. Note that the match_state dictionary does not need to have an entry 340 corresponding to each entry in the state dictionary. But for each entry 341 that it does have, the corresponding state entry will be checked for a 342 match. 343 344 Description of argument(s): 345 state A state dictionary such as the one returned by the 346 get_state function. 347 match_state A dictionary whose key/value pairs are "state field"/ 348 "state value". The state value is interpreted as a 349 regular expression. Every value in this dictionary is 350 considered. When match_type is 'and', if each and every 351 comparison matches, the two dictionaries are considered to 352 be matching. If match_type is 'or', if any two of the 353 elements compared match, the two dictionaries are 354 considered to be matching. 355 356 This value may also be any string accepted by 357 return_state_constant (e.g. "standby_match_state"). In 358 such a case this function will call return_state_constant 359 to convert it to a proper dictionary as described above. 360 361 Finally, one special value is accepted for the key field: 362 expression_key(). If such an entry exists, its value is 363 taken to be a list of expressions to be evaluated. These 364 expressions may reference state dictionary entries by 365 simply coding them in standard python syntax (e.g. 366 state['key1']). What follows is an example expression: 367 368 "int(float(state['uptime'])) < int(state['elapsed_boot_time'])" 369 370 In this example, if the state dictionary's 'uptime' entry 371 is less than its 'elapsed_boot_time' entry, it would 372 qualify as a match. 373 match_type This may be 'and' or 'or'. 374 """ 375 376 error_message = gv.valid_value(match_type, valid_values=['and', 'or']) 377 if error_message != "": 378 BuiltIn().fail(gp.sprint_error(error_message)) 379 380 try: 381 match_state = return_state_constant(match_state) 382 except TypeError: 383 pass 384 385 default_match = (match_type == 'and') 386 for key, match_state_value in match_state.items(): 387 # Blank match_state_value means "don't care". 388 if match_state_value == "": 389 continue 390 if key == expressions_key(): 391 for expr in match_state_value: 392 # Use python interpreter to evaluate the expression. 393 match = eval(expr) 394 if match != default_match: 395 return match 396 else: 397 try: 398 match = (re.match(match_state_value, str(state[key])) is not None) 399 except KeyError: 400 match = False 401 if match != default_match: 402 return match 403 404 return default_match 405 406 407def get_os_state(os_host="", 408 os_username="", 409 os_password="", 410 req_states=default_os_req_states, 411 os_up=True, 412 quiet=None): 413 r""" 414 Get component states for the operating system such as ping, login, 415 etc, put them into a dictionary and return them to the caller. 416 417 Note that all substate values are strings. 418 419 Description of argument(s): 420 os_host The DNS name or IP address of the operating system. 421 This defaults to global ${OS_HOST}. 422 os_username The username to be used to login to the OS. 423 This defaults to global ${OS_USERNAME}. 424 os_password The password to be used to login to the OS. 425 This defaults to global ${OS_PASSWORD}. 426 req_states This is a list of states whose values are being requested by 427 the caller. 428 os_up If the caller knows that the os can't possibly be up, it can 429 improve performance by passing os_up=False. This function 430 will then simply return default values for all requested os 431 sub states. 432 quiet Indicates whether status details (e.g. curl commands) should 433 be written to the console. 434 Defaults to either global value of ${QUIET} or to 1. 435 """ 436 437 quiet = int(gp.get_var_value(quiet, 0)) 438 439 # Set parm defaults where necessary and validate all parms. 440 if os_host == "": 441 os_host = BuiltIn().get_variable_value("${OS_HOST}") 442 error_message = gv.valid_value(os_host, invalid_values=[None, ""]) 443 if error_message != "": 444 BuiltIn().fail(gp.sprint_error(error_message)) 445 446 if os_username == "": 447 os_username = BuiltIn().get_variable_value("${OS_USERNAME}") 448 error_message = gv.valid_value(os_username, invalid_values=[None, ""]) 449 if error_message != "": 450 BuiltIn().fail(gp.sprint_error(error_message)) 451 452 if os_password == "": 453 os_password = BuiltIn().get_variable_value("${OS_PASSWORD}") 454 error_message = gv.valid_value(os_password, invalid_values=[None, ""]) 455 if error_message != "": 456 BuiltIn().fail(gp.sprint_error(error_message)) 457 458 invalid_req_states = [sub_state for sub_state in req_states 459 if sub_state not in valid_os_req_states] 460 if len(invalid_req_states) > 0: 461 error_message = "The following req_states are not supported:\n" +\ 462 gp.sprint_var(invalid_req_states) 463 BuiltIn().fail(gp.sprint_error(error_message)) 464 465 # Initialize all substate values supported by this function. 466 os_ping = 0 467 os_login = 0 468 os_run_cmd = 0 469 470 if os_up: 471 if 'os_ping' in req_states: 472 # See if the OS pings. 473 rc, out_buf = gc.shell_cmd("ping -c 1 -w 2 " + os_host, 474 print_output=0, show_err=0, 475 ignore_err=1) 476 if rc == 0: 477 os_ping = 1 478 479 # Programming note: All attributes which do not require an ssh login 480 # should have been processed by this point. 481 master_req_login = ['os_login', 'os_run_cmd'] 482 req_login = [sub_state for sub_state in req_states if sub_state in 483 master_req_login] 484 must_login = (len(req_login) > 0) 485 486 if must_login: 487 output, stderr, rc = bsu.os_execute_command("uptime", quiet=quiet, 488 ignore_err=1, 489 time_out=20, 490 os_host=os_host, 491 os_username=os_username, 492 os_password=os_password) 493 if rc == 0: 494 os_login = 1 495 os_run_cmd = 1 496 else: 497 gp.dprint_vars(output, stderr) 498 gp.dprint_vars(rc, 1) 499 500 os_state = DotDict() 501 for sub_state in req_states: 502 cmd_buf = "os_state['" + sub_state + "'] = str(" + sub_state + ")" 503 exec(cmd_buf) 504 505 return os_state 506 507 508def get_state(openbmc_host="", 509 openbmc_username="", 510 openbmc_password="", 511 os_host="", 512 os_username="", 513 os_password="", 514 req_states=default_req_states, 515 quiet=None): 516 r""" 517 Get component states such as chassis state, bmc state, etc, put them into a 518 dictionary and return them to the caller. 519 520 Note that all substate values are strings. 521 522 Note: If elapsed_boot_time is included in req_states, it is the caller's 523 duty to call set_start_boot_seconds() in order to set global 524 start_boot_seconds. elapsed_boot_time is the current time minus 525 start_boot_seconds. 526 527 Description of argument(s): 528 openbmc_host The DNS name or IP address of the BMC. 529 This defaults to global ${OPENBMC_HOST}. 530 openbmc_username The username to be used to login to the BMC. 531 This defaults to global ${OPENBMC_USERNAME}. 532 openbmc_password The password to be used to login to the BMC. 533 This defaults to global ${OPENBMC_PASSWORD}. 534 os_host The DNS name or IP address of the operating system. 535 This defaults to global ${OS_HOST}. 536 os_username The username to be used to login to the OS. 537 This defaults to global ${OS_USERNAME}. 538 os_password The password to be used to login to the OS. 539 This defaults to global ${OS_PASSWORD}. 540 req_states This is a list of states whose values are being requested 541 by the caller. 542 quiet Indicates whether status details (e.g. curl commands) 543 should be written to the console. 544 Defaults to either global value of ${QUIET} or to 1. 545 """ 546 547 quiet = int(gp.get_var_value(quiet, 0)) 548 549 # Set parm defaults where necessary and validate all parms. 550 if openbmc_host == "": 551 openbmc_host = BuiltIn().get_variable_value("${OPENBMC_HOST}") 552 error_message = gv.valid_value(openbmc_host, invalid_values=[None, ""]) 553 if error_message != "": 554 BuiltIn().fail(gp.sprint_error(error_message)) 555 556 if openbmc_username == "": 557 openbmc_username = BuiltIn().get_variable_value("${OPENBMC_USERNAME}") 558 error_message = gv.valid_value(openbmc_username, invalid_values=[None, ""]) 559 if error_message != "": 560 BuiltIn().fail(gp.sprint_error(error_message)) 561 562 if openbmc_password == "": 563 openbmc_password = BuiltIn().get_variable_value("${OPENBMC_PASSWORD}") 564 error_message = gv.valid_value(openbmc_password, invalid_values=[None, ""]) 565 if error_message != "": 566 BuiltIn().fail(gp.sprint_error(error_message)) 567 568 # NOTE: OS parms are optional. 569 if os_host == "": 570 os_host = BuiltIn().get_variable_value("${OS_HOST}") 571 if os_host is None: 572 os_host = "" 573 574 if os_username == "": 575 os_username = BuiltIn().get_variable_value("${OS_USERNAME}") 576 if os_username is None: 577 os_username = "" 578 579 if os_password == "": 580 os_password = BuiltIn().get_variable_value("${OS_PASSWORD}") 581 if os_password is None: 582 os_password = "" 583 584 invalid_req_states = [sub_state for sub_state in req_states 585 if sub_state not in valid_req_states] 586 if len(invalid_req_states) > 0: 587 error_message = "The following req_states are not supported:\n" +\ 588 gp.sprint_var(invalid_req_states) 589 BuiltIn().fail(gp.sprint_error(error_message)) 590 591 # Initialize all substate values supported by this function. 592 ping = 0 593 packet_loss = '' 594 uptime = '' 595 epoch_seconds = '' 596 elapsed_boot_time = '' 597 rest = '' 598 redfish = '' 599 chassis = '' 600 requested_chassis = '' 601 bmc = '' 602 requested_bmc = '' 603 # BootProgress state will get populated when state logic enumerates the 604 # state URI. This is to prevent state dictionary boot_progress value 605 # getting empty when the BootProgress is NOT found, making it optional. 606 boot_progress = 'NA' 607 operating_system = '' 608 host = '' 609 requested_host = '' 610 attempts_left = '' 611 612 # Get the component states. 613 if 'ping' in req_states: 614 # See if the OS pings. 615 rc, out_buf = gc.shell_cmd("ping -c 1 -w 2 " + openbmc_host, 616 print_output=0, show_err=0, 617 ignore_err=1) 618 if rc == 0: 619 ping = 1 620 621 if 'packet_loss' in req_states: 622 # See if the OS pings. 623 cmd_buf = "ping -c 5 -w 5 " + openbmc_host +\ 624 " | egrep 'packet loss' | sed -re 's/.* ([0-9]+)%.*/\\1/g'" 625 rc, out_buf = gc.shell_cmd(cmd_buf, 626 print_output=0, show_err=0, 627 ignore_err=1) 628 if rc == 0: 629 packet_loss = out_buf.rstrip("\n") 630 631 if 'uptime' in req_states: 632 # Sometimes reading uptime results in a blank value. Call with 633 # wait_until_keyword_succeeds to ensure a non-blank value is obtained. 634 remote_cmd_buf = "bash -c 'read uptime filler 2>/dev/null < /proc/uptime" +\ 635 " && [ ! -z \"${uptime}\" ] && echo ${uptime}'" 636 cmd_buf = ["BMC Execute Command", 637 re.sub('\\$', '\\$', remote_cmd_buf), 'quiet=1', 638 'test_mode=0', 'time_out=5'] 639 gp.qprint_issuing(cmd_buf, 0) 640 gp.qprint_issuing(remote_cmd_buf, 0) 641 try: 642 stdout, stderr, rc =\ 643 BuiltIn().wait_until_keyword_succeeds("10 sec", "5 sec", 644 *cmd_buf) 645 if rc == 0 and stderr == "": 646 uptime = stdout 647 except AssertionError as my_assertion_error: 648 pass 649 650 if 'epoch_seconds' in req_states or 'elapsed_boot_time' in req_states: 651 date_cmd_buf = "date -u +%s" 652 if USE_BMC_EPOCH_TIME: 653 cmd_buf = ["BMC Execute Command", date_cmd_buf, 'quiet=${1}'] 654 if not quiet: 655 gp.print_issuing(cmd_buf) 656 status, ret_values = \ 657 BuiltIn().run_keyword_and_ignore_error(*cmd_buf) 658 if status == "PASS": 659 stdout, stderr, rc = ret_values 660 if rc == 0 and stderr == "": 661 epoch_seconds = stdout.rstrip("\n") 662 else: 663 shell_rc, out_buf = gc.cmd_fnc_u(date_cmd_buf, 664 quiet=quiet, 665 print_output=0) 666 if shell_rc == 0: 667 epoch_seconds = out_buf.rstrip("\n") 668 669 if 'elapsed_boot_time' in req_states: 670 global start_boot_seconds 671 elapsed_boot_time = int(epoch_seconds) - start_boot_seconds 672 673 if not redfish_support_trans_state: 674 master_req_rest = ['rest', 'host', 'requested_host', 'operating_system', 675 'attempts_left', 'boot_progress', 'chassis', 676 'requested_chassis' 'bmc' 'requested_bmc'] 677 678 req_rest = [sub_state for sub_state in req_states if sub_state in 679 master_req_rest] 680 need_rest = (len(req_rest) > 0) 681 state = DotDict() 682 if need_rest: 683 cmd_buf = ["Read Properties", SYSTEM_STATE_URI + "enumerate", 684 "quiet=${" + str(quiet) + "}", "timeout=30"] 685 gp.dprint_issuing(cmd_buf) 686 status, ret_values = \ 687 BuiltIn().run_keyword_and_ignore_error(*cmd_buf) 688 if status == "PASS": 689 state['rest'] = '1' 690 else: 691 state['rest'] = '0' 692 693 if int(state['rest']): 694 for url_path in ret_values: 695 # Skip conflicting "CurrentHostState" URL from the enum 696 # /xyz/openbmc_project/state/hypervisor0 697 if "hypervisor0" in url_path: 698 continue 699 700 if platform_arch_type == "x86": 701 # Skip conflicting "CurrentPowerState" URL from the enum 702 # /xyz/openbmc_project/state/chassis_system0 703 if "chassis_system0" in url_path: 704 continue 705 706 for attr_name in ret_values[url_path]: 707 # Create a state key value based on the attr_name. 708 try: 709 ret_values[url_path][attr_name] = \ 710 re.sub(r'.*\.', "", 711 ret_values[url_path][attr_name]) 712 except TypeError: 713 pass 714 # Do some key name manipulations. 715 new_attr_name = re.sub(r'^Current|(State|Transition)$', 716 "", attr_name) 717 new_attr_name = re.sub(r'BMC', r'Bmc', new_attr_name) 718 new_attr_name = re.sub(r'([A-Z][a-z])', r'_\1', 719 new_attr_name) 720 new_attr_name = new_attr_name.lower().lstrip("_") 721 new_attr_name = re.sub(r'power', r'chassis', new_attr_name) 722 if new_attr_name in req_states: 723 state[new_attr_name] = ret_values[url_path][attr_name] 724 else: 725 master_req_rf = ['redfish', 'host', 'requested_host', 726 'attempts_left', 'boot_progress', 'chassis', 727 'requested_chassis' 'bmc' 'requested_bmc'] 728 729 req_rf = [sub_state for sub_state in req_states if sub_state in 730 master_req_rf] 731 need_rf = (len(req_rf) > 0) 732 state = DotDict() 733 if need_rf: 734 cmd_buf = ["Redfish Get States"] 735 gp.dprint_issuing(cmd_buf) 736 try: 737 status, ret_values = \ 738 BuiltIn().run_keyword_and_ignore_error(*cmd_buf) 739 except Exception as ex: 740 # Robot raised UserKeywordExecutionFailed error exception. 741 gp.dprint_issuing("Retrying Redfish Get States") 742 status, ret_values = \ 743 BuiltIn().run_keyword_and_ignore_error(*cmd_buf) 744 745 gp.dprint_vars(status, ret_values) 746 if status == "PASS": 747 state['redfish'] = '1' 748 else: 749 state['redfish'] = '0' 750 751 if int(state['redfish']): 752 state['chassis'] = ret_values['chassis'] 753 state['host'] = ret_values['host'] 754 state['bmc'] = ret_values['bmc'] 755 if platform_arch_type != "x86": 756 state['boot_progress'] = ret_values['boot_progress'] 757 758 for sub_state in req_states: 759 if sub_state in state: 760 continue 761 if sub_state.startswith("os_"): 762 # We pass "os_" requests on to get_os_state. 763 continue 764 cmd_buf = "state['" + sub_state + "'] = str(" + sub_state + ")" 765 exec(cmd_buf) 766 767 if os_host == "": 768 # The caller has not specified an os_host so as far as we're concerned, 769 # it doesn't exist. 770 return state 771 772 os_req_states = [sub_state for sub_state in req_states 773 if sub_state.startswith('os_')] 774 775 if len(os_req_states) > 0: 776 # The caller has specified an os_host and they have requested 777 # information on os substates. 778 779 # Based on the information gathered on bmc, we'll try to make a 780 # determination of whether the os is even up. We'll pass the result 781 # of that assessment to get_os_state to enhance performance. 782 os_up_match = DotDict() 783 for sub_state in master_os_up_match: 784 if sub_state in req_states: 785 os_up_match[sub_state] = master_os_up_match[sub_state] 786 os_up = compare_states(state, os_up_match) 787 os_state = get_os_state(os_host=os_host, 788 os_username=os_username, 789 os_password=os_password, 790 req_states=os_req_states, 791 os_up=os_up, 792 quiet=quiet) 793 # Append os_state dictionary to ours. 794 state.update(os_state) 795 796 return state 797 798 799exit_wait_early_message = "" 800 801 802def set_exit_wait_early_message(value): 803 r""" 804 Set global exit_wait_early_message to the indicated value. 805 806 This is a mechanism by which the programmer can do an early exit from 807 wait_until_keyword_succeeds() based on some special condition. 808 809 Description of argument(s): 810 value The value to assign to the global 811 exit_wait_early_message. 812 """ 813 814 global exit_wait_early_message 815 exit_wait_early_message = value 816 817 818def check_state(match_state, 819 invert=0, 820 print_string="", 821 openbmc_host="", 822 openbmc_username="", 823 openbmc_password="", 824 os_host="", 825 os_username="", 826 os_password="", 827 quiet=None): 828 r""" 829 Check that the Open BMC machine's composite state matches the specified 830 state. On success, this keyword returns the machine's composite state as a 831 dictionary. 832 833 Description of argument(s): 834 match_state A dictionary whose key/value pairs are "state field"/ 835 "state value". The state value is interpreted as a 836 regular expression. Example call from robot: 837 ${match_state}= Create Dictionary chassis=^On$ 838 ... bmc=^Ready$ 839 ... boot_progress=^OSStart$ 840 ${state}= Check State &{match_state} 841 invert If this flag is set, this function will succeed if the 842 states do NOT match. 843 print_string This function will print this string to the console prior 844 to getting the state. 845 openbmc_host The DNS name or IP address of the BMC. 846 This defaults to global ${OPENBMC_HOST}. 847 openbmc_username The username to be used to login to the BMC. 848 This defaults to global ${OPENBMC_USERNAME}. 849 openbmc_password The password to be used to login to the BMC. 850 This defaults to global ${OPENBMC_PASSWORD}. 851 os_host The DNS name or IP address of the operating system. 852 This defaults to global ${OS_HOST}. 853 os_username The username to be used to login to the OS. 854 This defaults to global ${OS_USERNAME}. 855 os_password The password to be used to login to the OS. 856 This defaults to global ${OS_PASSWORD}. 857 quiet Indicates whether status details should be written to the 858 console. Defaults to either global value of ${QUIET} or 859 to 1. 860 """ 861 862 quiet = int(gp.get_var_value(quiet, 0)) 863 864 gp.gp_print(print_string) 865 866 try: 867 match_state = return_state_constant(match_state) 868 except TypeError: 869 pass 870 871 req_states = list(match_state.keys()) 872 # Remove special-case match key from req_states. 873 if expressions_key() in req_states: 874 req_states.remove(expressions_key()) 875 # Initialize state. 876 state = get_state(openbmc_host=openbmc_host, 877 openbmc_username=openbmc_username, 878 openbmc_password=openbmc_password, 879 os_host=os_host, 880 os_username=os_username, 881 os_password=os_password, 882 req_states=req_states, 883 quiet=quiet) 884 if not quiet: 885 gp.print_var(state) 886 887 if exit_wait_early_message != "": 888 # The exit_wait_early_message has been set by a signal handler so we 889 # will exit "successfully". It is incumbent upon the calling function 890 # (e.g. wait_state) to check/clear this variable and to fail 891 # appropriately. 892 return state 893 894 match = compare_states(state, match_state) 895 896 if invert and match: 897 fail_msg = "The current state of the machine matches the match" +\ 898 " state:\n" + gp.sprint_varx("state", state) 899 BuiltIn().fail("\n" + gp.sprint_error(fail_msg)) 900 elif not invert and not match: 901 fail_msg = "The current state of the machine does NOT match the" +\ 902 " match state:\n" +\ 903 gp.sprint_varx("state", state) 904 BuiltIn().fail("\n" + gp.sprint_error(fail_msg)) 905 906 return state 907 908 909def wait_state(match_state=(), 910 wait_time="1 min", 911 interval="1 second", 912 invert=0, 913 openbmc_host="", 914 openbmc_username="", 915 openbmc_password="", 916 os_host="", 917 os_username="", 918 os_password="", 919 quiet=None): 920 r""" 921 Wait for the Open BMC machine's composite state to match the specified 922 state. On success, this keyword returns the machine's composite state as 923 a dictionary. 924 925 Description of argument(s): 926 match_state A dictionary whose key/value pairs are "state field"/ 927 "state value". See check_state (above) for details. 928 This value may also be any string accepted by 929 return_state_constant (e.g. "standby_match_state"). 930 In such a case this function will call 931 return_state_constant to convert it to a proper 932 dictionary as described above. 933 wait_time The total amount of time to wait for the desired state. 934 This value may be expressed in Robot Framework's time 935 format (e.g. 1 minute, 2 min 3 s, 4.5). 936 interval The amount of time between state checks. 937 This value may be expressed in Robot Framework's time 938 format (e.g. 1 minute, 2 min 3 s, 4.5). 939 invert If this flag is set, this function will for the state of 940 the machine to cease to match the match state. 941 openbmc_host The DNS name or IP address of the BMC. 942 This defaults to global ${OPENBMC_HOST}. 943 openbmc_username The username to be used to login to the BMC. 944 This defaults to global ${OPENBMC_USERNAME}. 945 openbmc_password The password to be used to login to the BMC. 946 This defaults to global ${OPENBMC_PASSWORD}. 947 os_host The DNS name or IP address of the operating system. 948 This defaults to global ${OS_HOST}. 949 os_username The username to be used to login to the OS. 950 This defaults to global ${OS_USERNAME}. 951 os_password The password to be used to login to the OS. 952 This defaults to global ${OS_PASSWORD}. 953 quiet Indicates whether status details should be written to the 954 console. Defaults to either global value of ${QUIET} or 955 to 1. 956 """ 957 958 quiet = int(gp.get_var_value(quiet, 0)) 959 960 try: 961 match_state = return_state_constant(match_state) 962 except TypeError: 963 pass 964 965 if not quiet: 966 if invert: 967 alt_text = "cease to " 968 else: 969 alt_text = "" 970 gp.print_timen("Checking every " + str(interval) + " for up to " 971 + str(wait_time) + " for the state of the machine to " 972 + alt_text + "match the state shown below.") 973 gp.print_var(match_state) 974 975 if quiet: 976 print_string = "" 977 else: 978 print_string = "#" 979 980 debug = int(BuiltIn().get_variable_value("${debug}", "0")) 981 if debug: 982 # In debug we print state so no need to print the "#". 983 print_string = "" 984 check_state_quiet = 1 - debug 985 cmd_buf = ["Check State", match_state, "invert=${" + str(invert) + "}", 986 "print_string=" + print_string, "openbmc_host=" + openbmc_host, 987 "openbmc_username=" + openbmc_username, 988 "openbmc_password=" + openbmc_password, "os_host=" + os_host, 989 "os_username=" + os_username, "os_password=" + os_password, 990 "quiet=${" + str(check_state_quiet) + "}"] 991 gp.dprint_issuing(cmd_buf) 992 try: 993 state = BuiltIn().wait_until_keyword_succeeds(wait_time, interval, 994 *cmd_buf) 995 except AssertionError as my_assertion_error: 996 gp.printn() 997 message = my_assertion_error.args[0] 998 BuiltIn().fail(message) 999 1000 if exit_wait_early_message: 1001 # The global exit_wait_early_message was set by a signal handler 1002 # indicating that we should fail. 1003 message = exit_wait_early_message 1004 # Clear the exit_wait_early_message variable for future use. 1005 set_exit_wait_early_message("") 1006 BuiltIn().fail(gp.sprint_error(message)) 1007 1008 if not quiet: 1009 gp.printn() 1010 if invert: 1011 gp.print_timen("The states no longer match:") 1012 else: 1013 gp.print_timen("The states match:") 1014 gp.print_var(state) 1015 1016 return state 1017 1018 1019def set_start_boot_seconds(value=0): 1020 global start_boot_seconds 1021 start_boot_seconds = int(value) 1022 1023 1024set_start_boot_seconds(0) 1025 1026 1027def wait_for_comm_cycle(start_boot_seconds, 1028 quiet=None): 1029 r""" 1030 Wait for the BMC uptime to be less than elapsed_boot_time. 1031 1032 This function will tolerate an expected loss of communication to the BMC. 1033 This function is useful when some kind of reboot has been initiated by the 1034 caller. 1035 1036 Description of argument(s): 1037 start_boot_seconds The time that the boot test started. The format is the 1038 epoch time in seconds, i.e. the number of seconds since 1039 1970-01-01 00:00:00 UTC. This value should be obtained 1040 from the BMC so that it is not dependent on any kind of 1041 synchronization between this machine and the target BMC 1042 This will allow this program to work correctly even in 1043 a simulated environment. This value should be obtained 1044 by the caller prior to initiating a reboot. It can be 1045 obtained as follows: 1046 state = st.get_state(req_states=['epoch_seconds']) 1047 """ 1048 1049 quiet = int(gp.get_var_value(quiet, 0)) 1050 1051 # Validate parms. 1052 error_message = gv.valid_integer(start_boot_seconds) 1053 if error_message: 1054 BuiltIn().fail(gp.sprint_error(error_message)) 1055 1056 # Wait for uptime to be less than elapsed_boot_time. 1057 set_start_boot_seconds(start_boot_seconds) 1058 expr = 'int(float(state[\'uptime\'])) < int(state[\'elapsed_boot_time\'])' 1059 match_state = DotDict([('uptime', '^[0-9\\.]+$'), 1060 ('elapsed_boot_time', '^[0-9]+$'), 1061 (expressions_key(), [expr])]) 1062 wait_state(match_state, wait_time="12 mins", interval="5 seconds") 1063 1064 gp.qprint_timen("Verifying that REST/Redfish API interface is working.") 1065 if not redfish_support_trans_state: 1066 match_state = DotDict([('rest', '^1$')]) 1067 else: 1068 match_state = DotDict([('redfish', '^1$')]) 1069 state = wait_state(match_state, wait_time="5 mins", interval="2 seconds") 1070