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)
