#!/usr/bin/python3 ############################################################################### # # Copyright (c) 2019-2020 Wind River Systems, Inc. # # SPDX-License-Identifier: Apache-2.0 # """Redfish Virtual Media Controller""" ############################################################################### # # This Redfish Virtual Media Controller forces an install of a specified BMC's # host using the Redfish Platform management protocol. # # To do so the following Redfish operations are performed # # Step 1: Client Connect ... Establish a client connection to the BMC # Step 2: Root Query ... Learn Redfish Services offered by the BMC # Step 3: Find CD/DVD ... Locate the virtual media CD/DVD device # Step 4: Power Off Host ... Host power needs to be off # Step 5: Eject Iso ... Eject iso if needed # Step 6: Inject Iso ... Inject the URL based ISO image into CD/DVD # Step 7: Force DVD Boot ... Set Net boot device to be CD/DVD # Step 8: Power On Host ... Host will boot and install from DVD # # Note: All server starting state conditions such as the server running or # being stuck in POST, say at the grub prompt due to previous host boot # failure, the host needs to be in the powered off state for the ISO # Insertion and Set DVD for Next Boot steps. # # Calling Sequence: Single Server Config # # > rvmc.py # # Config file assumed to be '/etc/rvmc.yaml' with the following format # # bmc_address: # bmc_username: # bmc_password: # image: http://://bootimage.iso # # Real Example: # # bmc_address: 123.45.67.89 # bmc_username: root # bmc_password: TGk2OW51eCo= # image: http://[2620:10a:a001:a103::81]:8080/iso/sub_cloud_bootimage.iso # # Optional Arguments: Additional arguments inform the tool to look for a # multi target config file and enable debug logs # # --target # # Multi Server Config : Each BMC is represented by an arbitrary target name # ------------------- under a primary label called virtual_media_iso. # # Config file assumed to be '/etc/rvmc.yaml' with the following format # # virtual_media_iso: # dcloud1: # bmc_address: # bmc_username: # bmc_password: # image: http://://bootimage.iso # dcloud2: # bmc_address: # bmc_username: # bmc_password: # image: http://://bootimage.iso # dcloud3: # bmc_address: # bmc_username: # bmc_password: # image: http://://bootimage.iso # # > rvmc.py --target dcloud1,dcloud2,dcloud3 --debug level # # --debug <0 .. 4> # # Note: 0 no debug info # 1 = execution stage # 2 + http request logs # 3 + headers and payloads and misc other # 4 + json output of all command responses # # > rvmc.py --target dcloud1,dcloud2,dcloud3 --debug # ############################################################################### # # Code structure: Note: any error causes error log, session close and exit # # parse command line arguments # # for each target # create object # # for each object # execute(object) # _redfish_client_connect ... connect to bmc # _redfish_root_query ... get base url tree # _redfish_create_session ... authenticated session # _redfish_get_managers ... get managers urls # _redfish_get_systems_members .. get systems members info # _redfish_get_vm_url ... get cd/dvd vm url # _redfish_load_vm_actions ... get eject/insert action urls/info # _redfish_poweroff_host ... tell bmc to power-off the host # _redfish_eject_image ... eject current media if present # _redfish_insert_image ... insert and verify insertion of iso # _redfish_set_boot_override ... set boot from cd/dvd on next reset # _redfish_poweron_host ... tell bmc to power-on the host # ############################################################################### import argparse import base64 import datetime import json import os import socket import sys import time import yaml # Import Redfish Python Library # Module: https://pypi.org/project/redfish/ import redfish FEATURE_NAME = 'Redfish Virtual Media Controller' VERSION_MAJOR = 2 VERSION_MINOR = 1 POWER_ON = 'On' POWER_OFF = "Off" # The host system's mounted rvmc config file CONFIG_FILE = '/etc/rvmc.yaml' # Parse command line arguments # ---------------------------- parser = argparse.ArgumentParser(description=FEATURE_NAME) parser.add_argument("--target", type=str, required=False, help="One or more bmc host descriptor targets ;\n" "type: comma delimited target list") parser.add_argument("--debug", type=int, required=False, default=0, help="Optional debug level ; 1..4") # get command line arguments args = parser.parse_args() # get debug level debug = args.debug # target list ; assumes none or comma delimited list targets = [] if args.target and args.target != 'None': targets = args.target.split(',') def t(): """ Return current time for log functions """ return datetime.datetime.now().replace(microsecond=0) def ilog(string): """ Info Log Utility """ sys.stdout.write("\n%s Info : %s" % (t(), string)) def elog(string): """ Error Log Utility """ sys.stdout.write("\n%s Error : %s" % (t(), string)) def alog(string): """ Action Log Utility """ sys.stdout.write("\n%s Action: %s" % (t(), string)) def dlog1(string, level=1): """ Debug Log - Level """ if debug and level <= debug: sys.stdout.write("\n%s Debug%d: %s" % (t(), level, string)) def dlog2(string): """ Debug Log - Level 2 """ dlog1(string, 2) def dlog3(string): """ Debug Log - Level 3 """ dlog1(string, 3) def dlog4(string): """ Debug Log - Level 4 """ dlog1(string, 4) def slog(stage): """Execution Stage Log""" sys.stdout.write("\n%s Stage : %s" % (t(), stage)) def rvmc_exit(code): """Exit not tied to object ; early fault handling""" sys.stdout.write("\n\n") sys.exit(code) ilog("%s version %d.%d\n" % (FEATURE_NAME, VERSION_MAJOR, VERSION_MINOR)) dlog1("Debug : %d" % debug) if len(targets): dlog1("Targets : %s" % (args.target)) # start with an empty object list target_object_list = [] # Constants # --------- REDFISH_ROOT_PATH = '/redfish/v1' PRIMARY_CONFIG_LABEL = 'virtual_media_iso' # Primary Config label SUPPORTED_VIRTUAL_MEDIA_DEVICES = ['CD', 'DVD'] # Maybe add USB to list # headers for each request type HDR_CONTENT_TYPE = "'Content-Type': 'application/json'" HDR_ACCEPT = "'Accept': 'application/json'" # they all happen to be the same right now GET_HEADERS = {HDR_CONTENT_TYPE, HDR_ACCEPT} POST_HEADERS = {HDR_CONTENT_TYPE, HDR_ACCEPT} PATCH_HEADERS = {HDR_CONTENT_TYPE, HDR_ACCEPT} # HTTP request types ; only 3 are required by this tool POST = 'POST' GET = 'GET' PATCH = 'PATCH' # max number of polling retries while waiting for some long task to complete MAX_POLL_COUNT = 200 # some servers timeout on inter comm gaps longer than 10 secs RETRY_DELAY_SECS = 10 # 2 second delay constant DELAY_2_SECS = 2 def is_ipv6_address(address): """ Check IPv6 Address. :param address: the ip address to compare user name. :type address: str. :returns bool: True if address is an IPv6 address else False """ try: socket.inet_pton(socket.AF_INET6, address) dlog3("Address : %s is IPv6" % address) except socket.error: dlog3("Address : %s is IPv4" % address) return False return True def supported_device(devices): """ Supported Device :param devices: list of devices :type : list :returns True if a device in devices list is in the SUPPORTED_VIRTUAL_MEDIA_DEVICES list. Otherwise False is returned. """ for device in devices: if device in SUPPORTED_VIRTUAL_MEDIA_DEVICES: return True return False def parse_target(target_name, target_dict): """ Parse key value pairs in target and if successful create a vmcObject and add it to the target_object_list. :param target_name: arbitrary target label :type target_name: str. :param target_dict: dictionary of key value config file pairs :type target_dict: dictionary :returns nothing """ dlog3("Parse Target: %s:%s" % (target_name, target_dict)) pw = target_dict.get('bmc_password') if pw is None: elog("Failed get bmc password from config file") return try: pw_dec = base64.b64decode(pw).decode('utf-8') except Exception as ex: elog("Failed to decode bmc password found in config file (%s)" % ex) alog("Verify config file's bmc password is base64 encoded") return address = target_dict.get('bmc_address') if address is None: elog("Failed to decode bmc password found in %s" % CONFIG_FILE) alog("Verify config file's bmc password is base64 encoded") return #################################################################### # # Add url encoding [] for ipv6 addresses only. # # Note: The imported redfish library produces a python exception # on the session close if the ipv4 address has [] around it. # # I debugged the issue and know what it is and how to fix it # but requires an upstream change that is not worth doing. # # URL Encoding for IPv6 only is an easy solution. # ###################################################################### if is_ipv6_address(address) is True: bmc_ipv6 = True address = '[' + address + ']' else: bmc_ipv6 = False # Create object and add it to the target object list try: vmc_obj = VmcObject(target_name, address, target_dict.get('bmc_username'), pw, str(pw_dec), target_dict.get('image')) if vmc_obj: vmc_obj.ipv6 = bmc_ipv6 target_object_list.append(vmc_obj) else: elog("Unable to create control object for target:%s ; " "skipping ..." % target_dict) except Exception as ex: elog("Unable to parse configuration for '%s' (%s)" "in config file." % (target_dict, ex)) alog("Check presence and spelling of configuration" " members under '%s' for target '%s'." % (PRIMARY_CONFIG_LABEL, target_dict)) return class VmcObject(object): """ Virtual Media Controller Class Object. One for each BMC """ def __init__(self, hostname, address, username, password, password_decoded, image): self.target = hostname self.uri = "https://" + address self.url = REDFISH_ROOT_PATH self.un = username.rstrip() self.ip = address.rstrip() self.pw_encoded = password.rstrip() self.pw = password_decoded self.img = image.rstrip() self.ipv6 = False self.redfish_obj = None # redfish client connection object self.session = False # True when session for this BMC is created self.response = None # holds response from last http request self.response_json = None # json formatted version of above response self.response_dict = None # dictionary version of aboe response # redfish root query response self.root_query_info = None # json version of the full root query # Managers Info self.managers_group_url = None self.manager_members_list = [] # Virtual Media Info self.vm_url = None self.vm_eject_url = None self.vm_group_url = None self.vm_group = None self.vm_label = None self.vm_version = None self.vm_actions = {} self.vm_members_array = [] self.vm_media_types = [] # systems info self.systems_group_url = None self.systems_member_url = None self.systems_members_list = [] self.systems_members = 0 self.power_state = None # boot control info self.boot_control_dict = {} # systems reset info self.reset_command_url = None self.reset_action_dict = {} # parsed target object info if self.target is not None: dlog1("Target : %s" % self.target) dlog1("BMC IP : %s" % self.ip) dlog1("Username : %s" % self.un) dlog1("Password : %s" % self.pw_encoded) dlog1("Image : %s" % self.img) def make_request(self, operation=None, path=None, payload=None): """ Issue a Redfish http request, Check response, Convert response to dictionary format Convert response to json format :param operation: HTTP GET, POST or PATCH operation :type operation: str. :param path: url to perform request to :type path: str :param payload: POST or PATCH payload data :type payload: dictionary :returns True if request succeeded (200,202(accepted),204(no content) """ self.response = None if path is not None: url = path else: url = self.url before_request_time = datetime.datetime.now().replace(microsecond=0) try: dlog3("Request : %s %s" % (operation, url)) if operation == GET: dlog3("Headers : %s : %s" % (operation, GET_HEADERS)) self.response = self.redfish_obj.get(url, headers=GET_HEADERS) elif operation == POST: dlog3("Headers : %s : %s" % (operation, POST_HEADERS)) dlog3("Payload : %s" % payload) self.response = self.redfish_obj.post(url, body=payload, headers=POST_HEADERS) elif operation == PATCH: dlog3("Headers : %s : %s" % (operation, PATCH_HEADERS)) dlog3("Payload : %s" % payload) self.response = self.redfish_obj.patch(url, body=payload, headers=PATCH_HEADERS) else: elog("Unsupported operation: %s" % operation) return False except Exception as ex: elog("Failed operation on '%s' (%s)" % (url, ex)) if self.response is not None: after_request_time = datetime.datetime.now().replace(microsecond=0) delta = after_request_time - before_request_time # if we got a response, check its status if self.check_ok_status(url, operation, delta.seconds) is False: self._exit(1) # handle 204 success with no content ; clear last response if self.response.status == 204: self.response = "" return True try: if self.resp_dict() is True: if self.format() is True: dlog4("Response:\n%s\n" % self.response_json) return True else: elog("Failed to parse BMC %s response '%s'" % (operation, url)) except Exception as ex: elog("Failed to parse BMC %s response '%s' (%s)" % (operation, url, ex)) elog("Response:\n%s\n" % self.response) else: elog("No response from %s:%s" % (operation, url)) return False def resp_dict(self): """ Create Response Dictionary """ if self.response.read: self.response_dict = None try: self.response_dict = json.loads(self.response.read) return True except Exception as ex: elog("Got exception key valuing response ; (%s)" % ex) elog("Response: " % self.response.read) else: elog("No response from last command") return False def format(self): """ Format Response as Json """ self.response_json = None try: if self.resp_dict() is True: self.response_json = json.dumps(self.response_dict, indent=4, sort_keys=True) return True else: return False except Exception as ex: elog("Got exception formatting response ; (%s)\n" % ex) return False def get_key_value(self, key1, key2=None): """ Get key1 value if no key2 is specified. Get key2 value from key1 value if key2 is specified. :param : key1 value is returned if no key2 is provided. :type : str. :param : key2 value is optional but if provided its value is returned :type : str :returns key1 value or key2 value if key2 is specified """ value1 = self.response_dict.get(key1) if key2 is None: return value1 return value1.get(key2) def check_ok_status(self, function, operation, seconds): """ Status :param function: description of operation :type : str :param operation: http GET, POST or PATCH :type : str :returns True if response status is OK. Otherwise False. """ # Accept applicable 400 series error from an Eject Request POST. # This error is dealt with by the eject handler. if self.response.status in [400, 403, 404] and \ function == self.vm_eject_url and \ operation == POST: return True if self.response.status not in [200, 202, 204]: try: elog("HTTP Status : %d ; %s %s failed after %i seconds\n%s\n" % (self.response.status, operation, function, seconds, json.dumps(self.response.dict, indent=4, sort_keys=True))) return False except Exception as ex: elog("check status exception ; %s" % ex) dlog2("HTTP Status : %s %s Ok (%d) (took %i seconds)" % (operation, function, self.response.status, seconds)) return True def _exit(self, code): """ Exit the tool but not before closing an open Redfish client connection. :param code: the exit code :type code: int """ if self.redfish_obj is not None and self.session is True: try: self.redfish_obj.logout() self.redfish_obj = None self.session = False dlog1("Session : Closed") except Exception as ex: elog("Session close failed ; %s" % ex) alog("Check BMC username and password in config file") if code: sys.stdout.write("\n-------------------------------------------\n") # If exit with reason code then print that reason code and dump # the redfish query data that was learned up to that point elog("Code : %s" % code) # Other info ilog("IPv6 : %s" % self.ipv6) # Root Query Info ilog("Root Query: %s" % self.root_query_info) # Managers Info ilog("Manager URL: %s" % self.managers_group_url) ilog("Manager Members List: %s" % self.manager_members_list) # Systems Info ilog("Systems Group URL: %s" % self.systems_group_url) ilog("Systems Member URL: %s" % self.systems_member_url) ilog("Systems Members: %d" % self.systems_members) ilog("Systems Members List: %s" % self.systems_members_list) ilog("Power State: %s" % self.power_state) ilog("Reset Actions: %s" % self.reset_action_dict) ilog("Reset Command URL: %s" % self.reset_command_url) ilog("Boot Control Dict: %s" % self.boot_control_dict) ilog("VM Members Array: %s" % self.vm_members_array) ilog("VM Group URL: %s" % self.vm_group_url) ilog("VM Group: %s" % self.vm_group) ilog("VM URL: %s" % self.vm_url) ilog("VM Label: %s" % self.vm_label) ilog("VM Version: %s" % self.vm_version) ilog("VM Actions: %s" % self.vm_actions) ilog("VM Media Types: %s" % self.vm_media_types) ilog("Last Response raw: %s" % self.response) ilog("Last Response json: %s" % self.response_json) rvmc_exit(code) ########################################################################### # # P R I V A T E S T A G E M E M B E R F U N C T I O N S # ########################################################################### ########################################################################### # Redfish Client Connect ########################################################################### def _redfish_client_connect(self): """ Connect to target Redfish service. """ stage = 'Redfish Client Connection' slog(stage) # Verify ping response ping_ok = False ping_count = 0 MAX_PING_COUNT = 10 while ping_count < MAX_PING_COUNT and ping_ok is False: response = 0 if self.ipv6 is True: response = os.system("ping -6 -c 1 " + self.ip[1:-1] + " > /dev/null 2>&1") else: response = os.system("ping -c 1 " + self.ip + " > /dev/null 2>&1") if response == 0: ping_ok = True else: ping_count = ping_count + 1 ilog("BMC Ping : retry (%i of %i)" % (ping_count, MAX_PING_COUNT)) time.sleep(2) if ping_ok is False: elog("Unable to ping '%s' (%i)" % (self.ip, ping_count)) alog("Check BMC ip address is pingable") self._exit(1) else: ilog("BMC Ping Ok : %s (%i)" % (self.ip, ping_count)) # try to connect connect_error = False try: # One time Redfish Client Object Create self.redfish_obj = \ redfish.redfish_client(base_url=self.uri, username=self.un, password=self.pw, default_prefix=REDFISH_ROOT_PATH) if self.redfish_obj is None: connect_error = True elog("Unable to establish %s to BMC at %s" % (stage, self.uri)) except Exception as ex: connect_error = True elog("Unable to establish %s to BMC at %s (%s)" % (stage, self.uri, ex)) if connect_error is True: alog("Check BMC ip address is pingable and supports Redfish") self._exit(1) ########################################################################### # Redfish Root Query ########################################################################### def _redfish_root_query(self): """ Redfish Root Query """ stage = 'Root Query' slog(stage) if self.make_request(operation=GET, path=None) is False: elog("Failed %s GET request") self._exit(1) if self.response_json: self.root_query_info = self.response_json # extract the systems get url needed to learn reset # actions for the eventual reset. # # "Systems": { "@odata.id": "/redfish/v1/Systems/" }, # # See Reset section below ; following iso insertion where # systems_group_url is used. self.systems_group_url = self.get_key_value('Systems', '@odata.id') ########################################################################### # Create Redfish Communication Session ########################################################################### def _redfish_create_session(self): """ Create Redfish Communication Session """ stage = 'Create Communication Session' slog(stage) try: self.redfish_obj.login(auth="session") dlog1("Session : Open") self.session = True except Exception as ex: elog("Failed to Create session ; %s" % ex) self._exit(1) ########################################################################### # Query Redfish Managers ########################################################################### def _redfish_get_managers(self): """ Query Redfish Managers """ stage = 'Get Managers' slog(stage) # Virtual Media support is located through the # Managers link of the root query response. # # This section learns that Managers URL Link from the # Root Query Result: # # Expecting something like this ... # # { # ... # "Managers": # { # "@odata.id": "/redfish/v1/Managers/" # }, # ... # } # Get Managers Link from the last Get response currently # in self.response_json self.managers_group_url = self.get_key_value('Managers', '@odata.id') if self.managers_group_url is None: elog("Failed to learn BMC RedFish Managers link") self._exit(1) # Managers Query (/redfish/v1/Managers/) if self.make_request(operation=GET, path=self.managers_group_url) is False: elog("Failed GET Managers from %s" % self.managers_group_url) self._exit(1) # Look for the Managers 'Members' URL Link list from the Managers Query # # Expect something like this ... # # { # ... # "Members": # [ # { "@odata.id": "/redfish/v1/Managers/1/" } # ], # ... # } # Support multiple Managers in the list self.manager_members_list = self.get_key_value('Members') ###################################################################### # Get Systems Members ###################################################################### def _redfish_get_systems_members(self): """ Get Systems Members """ stage = 'Get Systems' slog(stage) # Query Systems Group URL for list of Systems Members if self.make_request(operation=GET, path=self.systems_group_url) is False: elog("Unable to %s Members from %s" % (stage, self.systems_group_url)) self._exit(1) self.systems_members_list = self.get_key_value('Members') dlog3("Systems Members List: %s" % self.systems_members_list) if self.systems_members_list is None: elog("Systems Members URL GET Response\n%s" % self.response_json) self._exit(1) self.systems_members = len(self.systems_members_list) if self.systems_members == 0: elog("BMC not publishing any System Members:\n%s" % self.response_json) self._exit(1) ###################################################################### # Power On or Off Host ###################################################################### def _redfish_powerctl_host(self, state): """ Power On or Off the Host """ stage = 'Power ' + state + ' Host' slog(stage) if self.power_state == state: # already in required state return # Walk the Systems Members list looking for Action support. # # "Members": [ { "@odata.id": "/redfish/v1/Systems/1/" } ], # # Loop over Systems Members List looking for Reset Actions Dictionary info = 'Redfish Systems Actions Member' self.systems_member_url = None for member in range(self.systems_members): systems_member = self.systems_members_list[member] if systems_member: self.systems_member_url = systems_member.get('@odata.id') if self.systems_member_url is None: elog("Unable to get %s URL:\n%s\n" % (info, self.response_json)) self._exit(1) if self.make_request(operation=GET, path=self.systems_member_url) is False: elog("Unable to get %s from %s" % (info, self.systems_member_url)) self._exit(1) # Look for Reset Actions Dictionary self.reset_action_dict = \ self.get_key_value('Actions', '#ComputerSystem.Reset') if self.reset_action_dict is None: # try other URL self.systems_member_url = None continue else: # Got the Reset Actions Dictionary # get powerState self.power_state = self.get_key_value('PowerState') # Ensure we don't issue current state command if state in [POWER_OFF, POWER_ON]: # This is a Power ON or Off command if self.power_state == state: dlog2("Power already %s" % state) # ... AND we are already in that state then # we are done. Issuing a power command while # in the same state will error out. # So don't do it. return break info = 'Systems Reset Action Dictionary' if self.reset_action_dict is None: elog("BMC not publishing %s:\n%s\n" % (info, self.response_json)) self._exit(1) ############################################################## # Reset Actions Dictionary. This is what we are looking for # ############################################################## # # Look for Reset Actions label # # "Actions": # { # "#ComputerSystem.Reset": # { # "ResetType@Redfish.AllowableValues": [ # "On", # "ForceOff", # "ForceRestart", # "Nmi", # "PushPowerButton" # ], # "target":"/redfish/v1/Systems/1/Actions/ComputerSystem.Reset/" # } # } # # Need to get 2 pieces of information out of the Actions output # # 1. the Redfish Systems Reset Action Target # 2. the Redfish Systems Reset Action List # ############################################################### info = 'Systems Reset Action Target' self.reset_command_url = self.reset_action_dict.get('target') if self.reset_command_url is None: elog("Unable to get Reset Command URL (members:%d)\n%s" % (self.systems_members, self.reset_action_dict)) self._exit(1) # With the reset target url in hand, all that is needed now # is the reset command this target supports # # The reset command list looks like this. # # "ResetType@Redfish.AllowableValues": [ # "On", # "ForceOff", # "ForceRestart", # "Nmi", # "PushPowerButton" # ], # # Some targets support GracefulRestart and/or ForceRestart info = 'Allowable Reset Actions' reset_command_list = \ self.reset_action_dict.get('ResetType@Redfish.AllowableValues') if reset_command_list is None: elog("BMC is not publishing any %s" % info) self._exit(1) dlog3("ResetActions: %s" % reset_command_list) # load the appropriate acceptable command list if state == POWER_OFF: acceptable_commands = ['ForceOff', 'GracefulShutdown'] elif state == POWER_ON: acceptable_commands = ['ForceOn', 'On'] else: acceptable_commands = ['ForceRestart', 'GracefulRestart'] # Look for the best command for the power state requested. command = None for acceptable_command in acceptable_commands: for reset_command in reset_command_list: if reset_command == acceptable_command: command = reset_command break else: continue break if command is None: elog("Failed to find acceptable Power %s command in:\n%s" % (state, reset_command_list)) self._exit(1) # All that is left to do is POST the reset command # to the reset_command_url. payload = {'ResetType': command} if self.make_request(operation=POST, payload=payload, path=self.reset_command_url) is False: elog("Failed to Power %s Host" % state) self._exit(1) if state not in [POWER_OFF, POWER_ON]: # no need to refresh power state if # this was not a power command return # poll for requested power state. poll_count = 0 MAX_STATE_POLL_COUNT = 60 # some servers take longer than 10 seconds while poll_count < MAX_STATE_POLL_COUNT and self.power_state != state: time.sleep(1) poll_count = poll_count + 1 # get systems info if self.make_request(operation=GET, path=self.systems_member_url) is False: elog("Failed to Get System State (%i of %i)" % (poll_count, MAX_STATE_POLL_COUNT)) else: # get powerState self.power_state = self.get_key_value('PowerState') if self.power_state != state: dlog1("waiting for power %s (%s) (%d)" % (state, self.power_state, poll_count)) if self.power_state != state: elog("Failed to Set System Power State to %s (%s)" % (self.power_state, self.systems_member_url)) self._exit(1) else: ilog("%s verified (%d)" % (stage, poll_count)) ###################################################################### # Get CD/DVD Virtual Media URL ###################################################################### def _redfish_get_vm_url(self): """ Get CD/DVD Virtual Media URL from one of the Manager Members list """ stage = 'Get CD/DVD Virtual Media' slog(stage) if self.manager_members_list is None: elog("Unable to index Managers Members from %s" % self.managers_group_url) self._exit(1) members = len(self.manager_members_list) if members == 0: elog("BMC is not publishing any redfish Manager Members") self._exit(1) # Issue a Get from each 'Manager Member URL Link looking # for supported virtual devices. for member in range(members): member_url = None this_member = self.manager_members_list[member] if this_member: member_url = this_member.get('@odata.id') if member_url is None: continue if self.make_request(operation=GET, path=member_url) is False: elog("Unable to get Manager Member from %s" % member_url) self._exit(1) ######################################################## # Query Virtual Media # ######################################################## # Look for Virtual Media Support by this Manager Member # # Expect something like this ... # # { # ... # "VirtualMedia": # { # "@odata.id": "/redfish/v1/Managers/1/VirtualMedia/" # } # ... # } self.vm_group_url = None self.vm_group = self.get_key_value('VirtualMedia') if self.vm_group is None: if (member + 1) == members: elog("Virtual Media not supported by target BMC") self._exit(1) else: dlog3("Virtual Media not supported by member %d" % member) continue else: try: self.vm_group_url = self.vm_group.get('@odata.id') except Exception: elog("Unable to get Virtual Media Group from %s" % self.vm_group_url) self._exit(1) # Query this member's Virtual Media Service Group if self.make_request( operation=GET, path=self.vm_group_url) is False: elog("Failed to GET Virtual Media Service group from %s" % self.vm_group_url) continue # Look for Virtual Media Device URL Links # # Expect something like this ... # # { # ... # "Members": # [ # { "@odata.id": "/redfish/v1/Managers/1/VirtualMedia/1/" }, # { "@odata.id": "/redfish/v1/Managers/1/VirtualMedia/2/" } # ], # ... # } self.vm_members_array = [] try: self.vm_members_array = self.get_key_value('Members') vm_members = len(self.vm_members_array) except Exception: vm_members = 0 if vm_members == 0: elog("No Virtual Media members found at %s" % self.vm_group_url) self._exit(1) # Loop over each member's URL looking for the CD or DVD device # Consider trying the USB device as well if BMC supports that. for vm_member in range(vm_members): # Look for Virtual Media Device URL this_member = self.vm_members_array[vm_member] if this_member: self.vm_url = this_member.get('@odata.id') if self.make_request(operation=GET, path=self.vm_url) is False: elog("Failed to GET Virtual Media Service group from %s" % self.vm_group_url) continue # Query Virtual Media Device Type looking for supported device self.vm_media_types = self.get_key_value('MediaTypes') if self.vm_media_types is None: dlog3("No Virtual MediaTypes found at %s ; " "trying other members" % self.vm_url) break dlog4("Virtual Media Service:\n%s" % self.response_json) if supported_device(self.vm_media_types) is True: dlog3("Supported Virtual Media found at %s ; %s" % (self.vm_url, self.vm_media_types)) break else: dlog3("Virtual Media %s does not support CD/DVD ; " "trying other members" % self.vm_url) self.vm_url = None if self.vm_url is None: elog("Failed to find CD or DVD Virtual media type") self._exit(1) ###################################################################### # Load Selected Virtual Media Version and Actions ###################################################################### def _redfish_load_vm_actions(self): """ Load Selected Virtual Media Version and Actions """ stage = 'Load Selected Virtual Media Version and Actions' slog(stage) if self.vm_url is None: elog("Failed to find CD or DVD Virtual media type") self._exit(1) # Extract Virtual Media Version and Insert/Eject Actions # # Looks something like this. First half of odata.type is the VM label # # { # ... # "@odata.type": "#VirtualMedia.v1_2_0.VirtualMedia", # "Actions": { # "#VirtualMedia.EjectMedia": # { # "target" : # ".../Managers/1/VirtualMedia/2/Actions/VirtualMedia.EjectMedia/" # }, # "#VirtualMedia.InsertMedia": # { # "target": # ".../Managers/1/VirtualMedia/2/Actions/VirtualMedia.InsertMedia/" # } # ... # }, vm_data_type = self.get_key_value('@odata.type') if vm_data_type: self.vm_label = vm_data_type.split('.')[0] self.vm_version = vm_data_type.split('.')[1] self.vm_actions = self.get_key_value('Actions') dlog1("VM Version : %s" % self.vm_version) dlog1("VM Label : %s" % self.vm_label) dlog3("VM Actions :\n%s\n" % self.vm_actions) ###################################################################### # Power Off Host ###################################################################### def _redfish_poweroff_host(self): """ Power Off the Host """ self._redfish_powerctl_host(POWER_OFF) ###################################################################### # Eject Current Image ###################################################################### def _redfish_eject_image(self): """ Eject Current Image """ stage = 'Eject Current Image' slog(stage) if self.make_request(operation=GET, path=self.vm_url) is False: elog("Virtual media status query failed (%s)" % self.vm_url) self._exit(1) if self.get_key_value('Inserted') is False: return # Ensure there is no image inserted and handle the case where # one might be in the process of loading. MAX_EJECT_RETRY_COUNT = 10 eject_retry_count = 0 ejecting = True eject_media_label = '#VirtualMedia.EjectMedia' while eject_retry_count < MAX_EJECT_RETRY_COUNT and ejecting: eject_retry_count = eject_retry_count + 1 vm_eject = self.vm_actions.get(eject_media_label) if not vm_eject: elog("Failed to get eject target (%s)" % eject_media_label) self._exit(1) self.vm_eject_url = vm_eject.get('target') if self.vm_eject_url: if self.get_key_value('Image'): ilog("Eject Request Image %s" % (self.get_key_value('Image'))) else: dlog1("Eject Request") if self.make_request(operation=POST, payload={}, path=self.vm_eject_url) is False: elog("Eject request failed (%s)" % self.vm_eject_url) # accept this and continue to poll time.sleep(DELAY_2_SECS) poll_count = 0 while poll_count < MAX_POLL_COUNT and ejecting: # verify the image is not in inserted poll_count = poll_count + 1 vm_eject = self.vm_actions.get(eject_media_label) if self.make_request(operation=GET, path=self.vm_url) is True: if self.get_key_value('Inserted') is False: ilog("Ejected") ejecting = False elif self.get_key_value('Image'): # if image is present then its ready to # retry the eject, break out of poll loop dlog1("Image Present ; %s" % self.get_key_value('Image')) break else: dlog1("Eject Wait ; Image: %s" % self.get_key_value('Image')) time.sleep(RETRY_DELAY_SECS) else: elog("Failed to query vm state (%s)" % self.vm_url) self._exit(1) if ejecting is True: elog("%s wait timeout" % stage) self._exit(1) ###################################################################### # Insert Image into Virtual Media CD/DVD ###################################################################### def _redfish_insert_image(self): """ Insert Image into Virtual Media CD/DVD """ stage = 'Insert Image into Virtual Media CD/DVD' slog(stage) vm_insert_url = None vm_insert_act = self.vm_actions.get('#VirtualMedia.InsertMedia') if vm_insert_act: vm_insert_url = vm_insert_act.get('target') if vm_insert_url is None: elog("Unable to get Virtual Media Insertion URL\n%s\n" % self.response_json) self._exit(1) payload = {'Image': self.img, 'Inserted': True, 'WriteProtected': True} if self.make_request(operation=POST, payload=payload, path=vm_insert_url) is False: elog("Failed to Insert Media") self._exit(1) # Handle case where the BMC loads the iso image during the insertion. # In that case the 'Inserted' is True but the Image is not immediately # mounted. poll_count = 0 ImageInserting = True while poll_count < MAX_POLL_COUNT and ImageInserting: if self.make_request(operation=GET, path=self.vm_url) is False: elog("Unable to verify Image insertion (%s)" % self.vm_url) self._exit(1) if self.get_key_value('Image') == self.img: ilog("Image Insertion (took %i seconds)" % (poll_count * RETRY_DELAY_SECS)) ImageInserting = False else: time.sleep(RETRY_DELAY_SECS) poll_count = poll_count + 1 dlog1("Image Insertion Wait ; %3d secs (%3d of %3d)" % (poll_count * RETRY_DELAY_SECS, poll_count, MAX_POLL_COUNT)) if ImageInserting is True: elog("Image insertion timeout") self._exit(1) else: ilog("%s verified (took %i seconds)" % (stage, poll_count * RETRY_DELAY_SECS)) if self.get_key_value('Image') != self.img: elog("Insertion verification failed.") ilog("Expected Image: %s" % self.img) ilog("Detected Image: %s" % self.get_key_value('Image')) self._exit(1) # Verify Insertion # # Looking for the following values # dlog3("Image URI : %s" % self.get_key_value('Image')) dlog3("ImageName : %s" % self.get_key_value('ImageName')) dlog3("Inserted : %s" % self.get_key_value('Inserted')) dlog3("Protected : %s" % self.get_key_value('WriteProtected')) ###################################################################### # Set Next Boot Override to CD/DVD ###################################################################### def _redfish_set_boot_override(self): """ Set Next Boot Override to CD/DVD """ stage = 'Set Next Boot Override to CD/DVD' slog(stage) # Walk the Systems Members list looking for Boot support. # # "Members": [ { "@odata.id": "/redfish/v1/Systems/1/" } ], # # Loop over Systems Members List looking for Boot Dictionary info = 'Systems Boot Member' for member in range(self.systems_members): self.systems_member_url = None systems_member = self.systems_members_list[member] if systems_member: self.systems_member_url = systems_member.get('@odata.id') if self.systems_member_url is None: elog("Unable to get %s from %s" % (info, self.systems_members_list)) self._exit(1) if self.make_request(operation=GET, path=self.systems_member_url) is False: elog("Unable to get %s from %s" % (info, self.systems_member_url)) self._exit(1) # Look for Reset Actions Dictionary self.boot_control_dict = self.get_key_value('Boot') if self.boot_control_dict is None: continue if self.boot_control_dict is None: elog("Unable to get %s from %s" % (info, self.systems_member_url)) self._exit(1) else: allowable_label = 'BootSourceOverrideMode@Redfish.AllowableValues' mode_list = self.get_key_value('Boot', allowable_label) if mode_list is None: payload = {"Boot": {"BootSourceOverrideEnabled": "Once", "BootSourceOverrideTarget": "Cd"}} else: dlog1("Boot Override Modes: %s" % mode_list) # Prioritize UEFI over Legacy if "UEFI" in mode_list: payload = {"Boot": {"BootSourceOverrideEnabled": "Once", "BootSourceOverrideMode": "UEFI", "BootSourceOverrideTarget": "Cd"}} elif "Legacy" in mode_list: payload = {"Boot": {"BootSourceOverrideEnabled": "Once", "BootSourceOverrideMode": "Legacy", "BootSourceOverrideTarget": "Cd"}} else: elog("BootSourceOverrideModes %s not supported" % mode_list) self._exit(0) dlog2("Boot Override Payload: %s" % payload) if self.make_request(operation=PATCH, path=self.systems_member_url, payload=payload) is False: elog("Unable to Set Boot Override (%s)" % self.vm_url) self._exit(1) if self.make_request(operation=GET, path=self.systems_member_url) is False: elog("Unable to verify Set Boot Override (%s)" % self.vm_url) self._exit(1) else: enabled = self.get_key_value('Boot', 'BootSourceOverrideEnabled') device = self.get_key_value('Boot', 'BootSourceOverrideTarget') mode = self.get_key_value('Boot', 'BootSourceOverrideMode') if enabled == "Once" and \ supported_device(self.vm_media_types) is True: ilog("%s verified [%s:%s:%s]" % (stage, enabled, device, mode)) else: elog("Unable to verify Set Boot Override [%s:%s:%s]" % (enabled, device, mode)) self._exit(1) ###################################################################### # Power On Host ###################################################################### def _redfish_poweron_host(self): """ Power On or Off the Host """ self._redfish_powerctl_host(POWER_ON) def execute(self): """The main controller function that executes the iso insertion algorithm for the specified target object (self)""" self._redfish_client_connect() self._redfish_root_query() self._redfish_create_session() self._redfish_get_managers() self._redfish_get_systems_members() self._redfish_get_vm_url() self._redfish_load_vm_actions() self._redfish_eject_image() self._redfish_poweroff_host() self._redfish_insert_image() self._redfish_set_boot_override() self._redfish_poweron_host() ilog("Done") if self.redfish_obj is not None and self.session is True: self.redfish_obj.logout() dlog1("Session : Closed") ############################################################################## # # Load BMC target info from Config File. # For each BMC target create target object through parse_target. # Add each created target object to target_object_list. # Insert BMC iso for each object in target_object_list through self.execute # ############################################################################## # Find, Open and Read callers config file # --------------------------------------- cfg = None if not os.path.exists(CONFIG_FILE): elog("Unable to find specified config file: %s" % CONFIG_FILE) alog("Check config file spelling and presence\n\n") rvmc_exit(1) try: with open(CONFIG_FILE, 'r') as yaml_config: dlog1("Config File : %s" % CONFIG_FILE) cfg = yaml.safe_load(yaml_config) dlog3("Config Data : %s" % cfg) except Exception as ex: elog("Unable to open specified config file: %s (%s)" % (CONFIG_FILE, ex)) alog("Check config file access and permissions.\n\n") rvmc_exit(1) # Parse the config file # ---------------------- found = False # assume nothing is found to start # loop over all the sections looking for the primary config label for section in cfg: if section == PRIMARY_CONFIG_LABEL: # ... once found then loop over all the targets dlog2("VM Iso Label: %s" % cfg[section]) found = True if targets: dlog2("Using specified target(s): %s" % targets) else: for target in cfg[section]: targets.append(target) dlog1("Targets : %s" % targets) for target in targets: try: parse_target(target, cfg[section][target]) except Exception as ex: elog("Failed to parse info from '%s' target %s" % (target, ex)) alog("Verify %s file has %s target and such target " "is properly formatted" % (CONFIG_FILE, target)) continue # 'found' would still be false if the config file is for a single target if found is False: dlog3("Try single") parse_target(None, cfg) if len(target_object_list): # Load the Iso for all loaded objects for targetObj in target_object_list: if targetObj.target is not None: ilog("BMC Target : %s" % targetObj.target) if debug == 0: ilog("BMC IP Addr : %s" % targetObj.ip) ilog("Host Image : %s" % targetObj.img) targetObj.execute() else: elog("Operation aborted ; no valid bmc information found") if CONFIG_FILE and cfg: ilog("Config File :\n%s" % cfg) rvmc_exit(1) rvmc_exit(0)