def get_bmcstate(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) bmc_not_ready = bmc_state = 'NotReady' try: obmc.login() except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return bmc_state try: state = obmc.get_bmc_state() bmc_state = state.get('bmc') if bmc_state != 'Ready': bmc_state = bmc_not_ready self.callback.info('%s: %s' % (node, openbmc.RPOWER_STATES.get(bmc_state, bmc_state))) except SelfServerException as e: self.callback.error(openbmc.RPOWER_STATES[bmc_not_ready], node) except SelfClientException as e: self.callback.error("%s (%s)" % (openbmc.RPOWER_STATES[bmc_not_ready], e.message), node) return bmc_state
def dump_list(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) dump_info = [] try: obmc.login() dump_dict = obmc.list_dump_info() if not dump_dict: self.callback.info('%s: No attributes returned from the BMC.' % node) return dump_info keys = dump_dict.keys() keys.sort() for key in keys: info = '[%d] Generated: %s, Size: %s' % \ (key, dump_dict[key]['Generated'], dump_dict[key]['Size']) dump_info += info self.callback.info('%s: %s' % (node, info)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return dump_info
def _set_admin_password(self, admin_passwd, **kw): node = kw['node'] node_info = kw['nodeinfo'] origin_passwd, new_passwd = admin_passwd.split(',') if origin_passwd != node_info['password']: self.callback.error( 'Current BMC password is incorrect, cannot set the new password.', node) return obmc = openbmc.OpenBMCRest(name=node, nodeinfo=node_info, messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.set_admin_passwd(new_passwd) self.callback.info("%s: BMC Setting Password..." % node) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return self.callback.info( "%s: BMC password changed. Update 'bmcpasswd' for the node or the 'passwd' table with the new password." % node)
def upload_firm(self, upload_file, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() # Before uploading file, check CPU DD version inventory_info_dict = obmc.get_inventory_info('cpu') cpu_info = inventory_info_dict["CPU"] for info in cpu_info: if info.startswith("CPU0 Version : 20"): # Display warning the only certain firmware versions are supported on DD 2.0 self.callback.info( '%s: Warning: DD 2.0 processor detected on this node, should not have firmware > ibm-v2.0-0-r13.6 (BMC) and > v1.19_1.94 (Host).' % node) if info.startswith("CPU0 Version : 21"): if self.verbose: self.callback.info( '%s: DD 2.1 processor' % node) except (SelfServerException, SelfClientException) as e: return self._msg_process(node, e.message, msg_type='E') try: obmc.upload_firmware(self.firmware_file) self._msg_process(node, 'Firmware upload successful. Use -l option to list.') except (SelfServerException, SelfClientException) as e: return self._msg_process(node, e.message, msg_type='E')
def get_beacon_info(self, display_type, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) beacon_info = [] try: obmc.login() beacon_dict = obmc.get_beacon_info() beacon_info = self._get_beacon_info(beacon_dict, display_type) if not beacon_info: beacon_info = ['No attributes returned from the BMC.'] for info in beacon_info: self.callback.info('%s: %s' % (node, info)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return beacon_info
def list_firm_info(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) firm_info = [] try: obmc.login() has_functional, firm_obj_dict = obmc.list_firmware() except (SelfServerException, SelfClientException) as e: return self.callback.error(e.message, node) firm_info.append('%-8s %-7s %-10s %-s' % ('ID', 'Purpose', 'State', 'Version')) firm_info.append('-' * 55) for key, value in firm_obj_dict.items(): status = value.active if value.functional: status += '(*)' elif value.priority == 0: if not has_functional: status += '(*)' else: status += '(+)' firm_info.append('%-8s %-7s %-10s %-s' % (key.split('-')[-1], value.purpose, status, value.version)) for info in firm_info: self.callback.info('%s: %s' % (node, info)) return firm_info
def dump_process(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() flag = False dump_id = obmc.create_dump() self.callback.info('%s: Dump requested. Target ID is %s, waiting for BMC to generate...' % (node, dump_id)) for i in range(20): dump_dict = obmc.list_dump_info() if dump_id in dump_dict: flag = True break if (20-i) % 8 == 0: self.callback.info('%s: Still waiting for dump %s to be generated... ' % (node, dump_id)) sleep( 15 ) if flag: self._dump_download(obmc, node, str(dump_id), flag_dump_process=True) else: self.callback.error('Could not find dump %s after waiting %d seconds.' % (dump_id, 20 * 15), node) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def _get_apis_values(self, key, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() value = obmc.get_apis_values(key) except SelfServerException as e: return self.callback.error(e.message, node) except SelfClientException as e: if e.code == 404: return self.callback.error('404 Not Found - Requested endpoint does not exist or may ' \ 'indicate function is not supported on this OpenBMC firmware.', node) if e.code == 403: return self.callback.error('403 Forbidden - Requested endpoint does not exist or may ' \ 'indicate function is not yet supported by OpenBMC firmware.', node) return self.callback.error(e.message, node) if isinstance(value, dict): str_value = str(value.values()[0]) elif value: str_value = str(value) else: str_value = '0' result = '%s: %s: %s' % (node, openbmc.RSPCONFIG_APIS[key]['display_name'], str_value.split('.')[-1]) self.callback.info(result)
def get_bmcstate(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) bmc_not_ready = bmc_state = 'NotReady' try: obmc.login() except SelfServerException as e: # Special exception handling for login failure login_message = "Login to BMC failed: Can't connect to {0} {1}.".format( e.host_and_port, e.detail_msg) self.callback.error(login_message, node) return bmc_state try: state = obmc.get_bmc_state() bmc_state = state.get('bmc') if bmc_state != 'Ready': bmc_state = bmc_not_ready self.callback.info( '%s: %s' % (node, openbmc.RPOWER_STATES.get(bmc_state, bmc_state))) except SelfServerException, SelfClientException: # There is no response when BMC is not ready self.callback.error(openbmc.RPOWER_STATES[bmc_not_ready], node)
def get_ev_info(self, num_to_display, **kw): node = kw['node'] number_to_display = 0 try: # Number of records to display from the end number_to_display = 0-int(num_to_display) except Exception: # All records to display number_to_display = 0 obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) eventlog_info = [] try: obmc.login() # Get all eventlog records eventlog_info_dict = obmc.get_eventlog_info() keys = list(eventlog_info_dict.keys()) # Sort thy keys in natural order keys.sort(key=lambda x : int(x[0:])) # Display all, or specified number of records from the end for key in list(keys)[number_to_display:]: self.callback.info('%s: %s' % (node, eventlog_info_dict[key])) eventlog_info += eventlog_info_dict[key] except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return eventlog_info
def reboot(self, optype='boot', **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() states = obmc.list_power_states() status = obmc.get_host_state(states) new_status = '' if optype == 'reset' and status in ['Off', 'chassison']: status = openbmc.RPOWER_STATES['Off'] self.callback.info('%s: %s' % (node, status)) else: if status not in ['Off', 'off']: obmc.set_power_state('off') self.callback.update_node_attributes( 'status', node, POWER_STATE_DB['off']) off_flag = False start_timeStamp = int(time.time()) for i in range(0, 30): gevent.sleep(2) try: states = obmc.list_power_states() status = obmc.get_host_state(states) if openbmc.RPOWER_STATES.get(status) == 'off': off_flag = True break except SelfServerException as e: continue end_timeStamp = int(time.time()) if not off_flag: error = 'Error: Sent power-off command but state did not change ' \ 'to off after waiting %s seconds. (State= %s).' % (end_timeStamp - start_timeStamp, status) raise SelfServerException(error) for i in range(0, 2): try: ret = obmc.set_power_state('on') self.callback.update_node_attributes( 'status', node, POWER_STATE_DB['on']) self.callback.info('%s: %s' % (node, 'reset')) return except SelfServerException as e: self.callback.syslog('%s: %s' % (node, e.message)) gevent.sleep(1) continue self.callback.error(e.message, node) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def _get_netinfo(self, ip=False, ipsrc=False, netmask=False, gateway=False, vlan=False, hostname=False, ntpservers=False, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() netinfo = obmc.get_netinfo() except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return if not netinfo: return self.callback.error("No network information get", node) defaultgateway = "n/a" bmchostname = "" if 'defaultgateway' in netinfo: defaultgateway = netinfo["defaultgateway"] del netinfo["defaultgateway"] if 'hostname' in netinfo: bmchostname = netinfo["hostname"] del netinfo["hostname"] if hostname: self.callback.info("%s: BMC Hostname: %s" %(node, bmchostname)) if 'error' in netinfo: return self.callback.info('%s: %s' % (node, netinfo['error'])) dic_length = len(netinfo) netinfodict = {'ip':[], 'netmask':[], 'gateway':[], 'vlan':[], 'ipsrc':[], 'ntpservers':[]} for nic,attrs in netinfo.items(): addon_string = '' if dic_length > 1: addon_string = " for %s" % nic netinfodict['ip'].append("BMC IP"+addon_string+": %s" % attrs["ip"]) netinfodict['netmask'].append("BMC Netmask"+addon_string+": %s" % utils.mask_int2str(attrs["netmask"])) netinfodict['gateway'].append("BMC Gateway"+addon_string+": %s (default: %s)" % (attrs["gateway"], defaultgateway)) netinfodict['vlan'].append("BMC VLAN ID"+addon_string+": %s" % attrs["vlanid"]) netinfodict['ipsrc'].append("BMC IP Source"+addon_string+": %s" % attrs["ipsrc"]) netinfodict['ntpservers'].append("BMC NTP Servers"+addon_string+": %s" % attrs["ntpservers"]) if ip: for i in netinfodict['ip']: self.callback.info("%s: %s" % (node, i)) if netmask: for i in netinfodict['netmask']: self.callback.info("%s: %s" % (node, i)) if gateway: for i in netinfodict['gateway']: self.callback.info("%s: %s" % (node, i)) if ipsrc: for i in netinfodict['ipsrc']: self.callback.info("%s: %s" % (node, i)) if vlan: for i in netinfodict['vlan']: self.callback.info("%s: %s" % (node, i)) if ntpservers: for i in netinfodict['ntpservers']: self.callback.info("%s: %s" % (node, i)) return netinfo
def resolve_ev_records(self, resolve_list, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() # Get all eventlog records eventlog_info_dict = obmc.get_eventlog_info() keys = eventlog_info_dict.keys() # Sort the keys in natural order keys.sort(key=lambda x: int(x[0:])) resolved, ids = resolve_list.split('=') eventlog_ids_to_resolve = [] if ids.upper() == "LED": # loop through eventlog_info_dict and collect LED ids to be resolved into a eventlog_ids_to_resolve array for key in list(keys): if "[LED]" in eventlog_info_dict[key]: if "Resolved: 0" in eventlog_info_dict[key]: eventlog_ids_to_resolve.append(key) else: if self.verbose: self.callback.info( '%s: Not resolving already resolved eventlog ID %s' % (node, key)) else: # loop through list of ids and collect ids to resolve into a eventlog_ids_to_resolve array for id_to_resolve in ids.split(','): if id_to_resolve in eventlog_info_dict: if "Resolved: 0" in eventlog_info_dict[id_to_resolve]: eventlog_ids_to_resolve.append(id_to_resolve) else: if self.verbose: self.callback.info( '%s: Not resolving already resolved eventlog ID %s' % (node, id_to_resolve)) else: self.callback.info('%s: Invalid ID: %s' % (node, id_to_resolve)) if len(eventlog_ids_to_resolve) == 0: # At the end and there are no entries to resolve self.callback.info( '%s: No event log entries needed to be resolved' % node) else: # Resolve entries that were collected into the eventlog_ids_to_resolve array obmc.resolve_event_log_entries(eventlog_ids_to_resolve) for entry in eventlog_ids_to_resolve: self.callback.info('%s: Resolved %s' % (node, entry)) except (SelfServerException, SelfClientException) as e: self.callback.error('%s' % e.message, node)
def delete_firm(self, delete_id, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) error = '' try: obmc.login() except (SelfServerException, SelfClientException) as e: return self.callback.error(e.message, node) try: has_functional, firm_obj_dict = obmc.list_firmware() except (SelfServerException, SelfClientException) as e: return self.callback.error(e.message, node) host_flag = False for key, value in firm_obj_dict.items(): key_id = key.split('-')[-1] if key_id != delete_id: continue if value.functional or (value.priority == 0 and not has_functional): if value.purpose == 'BMC': return self.callback.error('Deleting currently active BMC firmware' \ ' is not supported', node) elif value.purpose == 'Host': host_flag = True break else: self.callback.error('Unable to determine the purpose of the ' \ 'firmware to delete', node) if host_flag: try: states = obmc.list_power_states() state = obmc.get_host_state(states) if openbmc.RPOWER_STATES.get(state) == 'on': return self.callback.error('Deleting currently active firmware on' \ ' powered on host is not supported', node) except (SelfServerException, SelfClientException) as e: return self.callback.error(e.message, node) try: obmc.delete_firmware(delete_id) except SelfServerException as e: error = e.message except SelfClientException as e: if e.code == 404: error = 'Invalid ID provided to delete. ' \ 'Use the -l option to view valid firmware IDs.' else: error = e.message if error: self.callback.error(error, node) else: self.callback.info('%s: [%s] Firmware removed' % (node, delete_id))
def flash_process(self, directory, no_host_reboot, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() except (SelfServerException, SelfClientException) as e: return self._msg_process(node, e.message, msg_type='E', update_rc=True) try: for key, value in self.firmware.items(): obmc.upload_firmware(value['file']) except (SelfServerException, SelfClientException) as e: return self._msg_process(node, e.message, msg_type='E', update_rc=True) activate_ids = self._get_firm_id(obmc, node) if not activate_ids: return for i in activate_ids: error = '' try: obmc.activate_firmware(i) except SelfServerException as e: error = e.message except SelfClientException as e: if e.code == 403: error = 'Invalid ID %s provided to activate. Use the -l option ' \ 'to view valid firmware IDs.' % i else: error = e.message if error: return self._msg_process(node, error, msg_type='E', update_rc=True) for key in self.firmware: msg = 'rflash %s started, please wait...' % key self._msg_process(node, msg, checkv=True) self._check_id_status(obmc, activate_ids, node, only_act=False) self._reboot_to_effect(obmc, no_host_reboot, node)
def activate_firm(self, activate_arg, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() except (SelfServerException, SelfClientException) as e: return self._msg_process(node, e.message, msg_type='E', update_rc=True) firmware_version = '' if self.firmware_file: firmware_version = self.firmware.keys()[0] try: obmc.upload_firmware(self.firmware_file) except (SelfServerException, SelfClientException) as e: return self._msg_process(node, e.message, msg_type='E', update_rc=True) activate_ids = self._get_firm_id(obmc, node) if not activate_ids: return activate_id = activate_ids[0] else: activate_id = activate_arg error = '' try: obmc.activate_firmware(activate_id) except SelfServerException as e: error = e.message except SelfClientException as e: if e.code == 403: error = 'Invalid ID provided to activate. ' \ 'Use the -l option to view valid firmware IDs.' else: error = e.message if error: return self._msg_process(node, error, msg_type='E', update_rc=True) msg = 'rflash %s started, please wait...' % firmware_version self._msg_process(node, msg, checkv=True) check_ids = [activate_id] self._check_id_status(obmc, check_ids, node)
def clear_all_ev_records(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.clear_all_eventlog_records() self.callback.info('%s: %s' % (node, "Logs cleared")) except (SelfServerException, SelfClientException) as e: self.callback.error('%s' % e.message, node)
def gard_clear(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.clear_gard() self.callback.info('%s: GARD cleared' % node) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def dump_clear(self, clear_arg, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.clear_dump(clear_arg) self.callback.info('%s: [%s] clear' % (node, clear_arg)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def _set_ntp_servers(self, servers, **kw): node = kw['node'] node_info = kw['nodeinfo'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=node_info, messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() netinfo = obmc.get_netinfo() except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return if not netinfo: return self.callback.error('No network information get', node) if 'error' in netinfo: self.callback.info('%s: %s' % (node, netinfo['error'])) return bmcip = node_info['bmcip'] nic = self._get_facing_nic(bmcip, netinfo) if not nic: return self.callback.error('Can not get facing NIC for %s' % bmcip, node) if (netinfo[nic]['ipsrc'] == 'DHCP'): return self.callback.error( 'BMC IP source is DHCP, could not set NTPServers', node) try: obmc.set_ntp_servers(nic, servers) self.callback.info('%s: BMC Setting NTPServers...' % node) netinfo = obmc.get_netinfo() except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return ntpservers = None if nic in netinfo: ntpservers = netinfo[nic]['ntpservers'] self.callback.info('%s: BMC NTP Servers: %s' % (node, ntpservers)) if ntpservers != None: # Display a warning if the host in not powered off # Time on the BMC is not synced while the host is powered on self.callback.info( '%s: Warning: time will not be synchronized until the host is powered off.' % node)
def set_state(self, state, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() ret = obmc.set_power_state(state) new_status = POWER_STATE_DB.get(state, '') self.callback.info('%s: %s' % (node, state)) if new_status: self.callback.update_node_attributes('status', node, new_status) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def set_state(self, state, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.set_beacon_state(state) self.callback.info('%s: %s' % (node, state)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def _set_apis_values(self, key, value, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.set_apis_values(key, value) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) self.callback.info("%s: BMC Setting %s..." % (node, openbmc.RSPCONFIG_APIS[key]['display_name']))
def get_info(self, inventory_type, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) inventory_info = [] try: obmc.login() inventory_info_dict = obmc.get_inventory_info() if inventory_type == 'all' or not inventory_type: keys = inventory_info_dict.keys() keys.sort() for key in keys: inventory_info += utils.sort_string_with_numbers( inventory_info_dict[key]) firm_dict_list = obmc.list_firmware() firm_info = self._get_firm_info(firm_dict_list) inventory_info += firm_info elif inventory_type == 'model' or inventory_type == 'serial': key = 'Model' if inventory_type == 'model' else 'SerialNumber' if 'SYSTEM' in inventory_info_dict: for system_info in inventory_info_dict['SYSTEM']: if key in system_info: inventory_info = [system_info] break else: key = inventory_type.upper() if key in inventory_info_dict: inventory_info = utils.sort_string_with_numbers( inventory_info_dict[key]) if not inventory_info: inventory_info = ['No attributes returned from the BMC.'] for info in inventory_info: self.callback.info('%s: %s' % (node, info)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return inventory_info
def get_state(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) state = 'Unknown' try: obmc.login() states = obmc.list_power_states() state = obmc.get_host_state(states) self.callback.info('%s: %s' % (node, openbmc.RPOWER_STATES.get(state, state))) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return state
def set_ipdhcp(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() obmc.set_ipdhcp() except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return self.callback.info("%s: BMC Setting IP to DHCP..." % (node)) try: obmc.reboot_bmc() except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node)
def dump_generate(self, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) dump_id = None try: obmc.login() dump_id = obmc.create_dump() if not dump_id: self.callback.info('%s: BMC returned 200 OK but no ID was returned. Verify manually on the BMC.' % node) else: self.callback.info('%s: [%s] success' % (node, dump_id)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return dump_id
def reboot_bmc(self, optype='warm', **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) new_status = '' try: obmc.login() except (SelfServerException, SelfClientException) as e: return self.callback.error(e.message, node) firm_obj_dict = {} try: has_functional, firm_obj_dict = obmc.list_firmware() except (SelfServerException, SelfClientException) as e: self.callback.syslog('%s: %s' % (node, e.message)) clear_flag = False for key, value in firm_obj_dict.items(): if not value.functional and value.priority == 0: clear_flag = True break if clear_flag: self.callback.info( '%s: Firmware will be flashed on reboot, deleting all BMC diagnostics...' % node) try: obmc.clear_dump('all') except (SelfServerException, SelfClientException) as e: self.callback.warn( '%s: Could not clear BMC diagnostics successfully %s' % (node, e.message)) try: obmc.reboot_bmc(optype) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) else: self.callback.info('%s: %s' % (node, openbmc.RPOWER_STATES['bmcreboot']))
def get_firm_info(self, target_file=None, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) firm_info = [] try: obmc.login() firm_dict_list = obmc.list_firmware() firm_info = self._get_firm_info(firm_dict_list) for info in firm_info: self.callback.info( '%s: %s' % (node, info)) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) return firm_info
def _get_apis_values(self, key, **kw): node = kw['node'] obmc = openbmc.OpenBMCRest(name=node, nodeinfo=kw['nodeinfo'], messager=self.callback, debugmode=self.debugmode, verbose=self.verbose) try: obmc.login() value = obmc.get_apis_values(key) except (SelfServerException, SelfClientException) as e: self.callback.error(e.message, node) str_value = '0.' + str(value) result = '%s: %s: %s' % (node, openbmc.RSPCONFIG_APIS[key]['display_name'], str_value.split('.')[-1]) self.callback.info(result)