def _set_boot_device(self, task, node, device, persistent=False): """Set the boot device for a node. :param task: a TaskManager instance. :param node: The Node. :param device: Boot device. One of [net, network, pxe, hd, cd, cdrom, dvd, floppy, default, setup, f1] :param persistent: Whether to set next-boot, or make the change permanent. Default: False. :raises: InvalidParameterValue if an invalid boot device is specified or required ipmi credentials are missing. :raises: IPMIFailure when the native ipmi call fails. """ if device not in ipmi_command.boot_devices: raise exception.InvalidParameterValue( _("Invalid boot device %s specified.") % device) driver_info = _parse_driver_info(node) try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) ipmicmd.set_bootdev(device) except pyghmi_exception.IpmiException as e: LOG.warning( _("IPMI set boot device failed for node %(node_id)s " "with the following error: %(error)s") % { 'node_id': driver_info['uuid'], 'error': str(e) }) raise exception.IPMIFailure(cmd=str(e))
def handle_power(self, ip, is_ipmi=False): if is_ipmi: bmc = ip else: a = ip.split(".") last_ = [str(int(a[-1]) + 100)] bmc = ".".join(a[:3] + last_) print_normal( "[ IPMIINFO ] ipmiip: {}, ipmiuser: {}, ipmipwd: {}".format( bmc, self._user, self._pwd)) try: ipmicmd = ipmi_command.Command(bmc=bmc, userid=self._user, password=self._pwd) except Exception: print_error("[ ERROR ] failed: not connect") return if self._get_power: try: ret = ipmicmd.get_power() except Exception as e: print_error("[ ERROR ] failed: {}".format(e)) else: print_ok("[ OK ] power is {}".format( ret.get("powerstate", "unknow"))) else: try: ret = ipmicmd.set_power(self._action, wait=5) except Exception as e: print_error("[ ERROR ] failed: {}".format(e)) else: status = ret.get("powerstate") if ret.get( "powerstate") else ret.get("pendingpowerstate") print_ok("[ OK ] power is {}".format(status, "unknow"))
def start_ipmi_chassis_uid_control(bmc_ip, bmc_username, bmc_password, uid_status, uid_duration=None): ipmi_chassis_uid_control_data = dict() ipmi_chassis_uid_control_data['action'] = 'IPMI - UID Control' try: connection_object = command.Command(bmc=bmc_ip, userid=bmc_username, password=bmc_password) if connection_object: cmd_results = connection_object.set_identify(on=uid_status, duration=uid_duration) # The results are always None, so let's expect its none for success too if cmd_results is None: ipmi_chassis_uid_control_data[ 'status'] = json_output_success_string ipmi_chassis_uid_control_data['data'] = cmd_results else: ipmi_chassis_uid_control_data['status'] = json_output_failed_string ipmi_chassis_uid_control_data[ 'data'] = json_ipmi_failed_connecting_string return json.dumps(ipmi_chassis_uid_control_data) except Exception as e: ipmi_chassis_uid_control_data['status'] = json_output_error_string ipmi_chassis_uid_control_data['data'] = "{}".format(e) return json.dumps(ipmi_chassis_uid_control_data)
def _power_off(driver_info): """Turn the power off for this node. :param driver_info: the bmc access info for a node. :returns: power state POWER_OFF, one of :class:`ironic.common.states`. :raises: IPMIFailure when the native ipmi call fails. :raises: PowerStateFailure when invalid power state is returned from ipmi. """ msg = _("IPMI power off failed for node %(node_id)s with the " "following error: %(error)s") try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) wait = CONF.ipmi.retry_timeout ret = ipmicmd.set_power('off', wait) except pyghmi_exception.IpmiException as e: error = msg % {'node_id': driver_info['uuid'], 'error': e} LOG.error(error) raise exception.IPMIFailure(error) state = ret.get('powerstate') if state == 'off': return states.POWER_OFF else: error = _("bad response: %s") % ret LOG.error(msg, {'node_id': driver_info['uuid'], 'error': error}) raise exception.PowerStateFailure(pstate=states.POWER_OFF)
def open(self) -> None: self._logger.debug("Connecting to %s:623 (User: %s, Privlevel: 2)", self._address, self._username) self._command = ipmi_cmd.Command(bmc=self._address, userid=self._username, password=self._password, privlevel=2)
def _power_status(driver_info): """Get the power status for this node. :param driver_info: the bmc access info for a node. :returns: power state POWER_ON, POWER_OFF or ERROR defined in :class:`ironic.common.states`. :raises: IPMIFailure when the native ipmi call fails. """ try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) ret = ipmicmd.get_power() except pyghmi_exception.IpmiException as e: LOG.warning(_LW("IPMI get power state failed for node %(node_id)s " "with the following error: %(error)s"), {'node_id': driver_info['uuid'], 'error': str(e)}) raise exception.IPMIFailure(cmd=str(e)) state = ret.get('powerstate') if state == 'on': return states.POWER_ON elif state == 'off': return states.POWER_OFF else: # NOTE(linggao): Do not throw an exception here because it might # return other valid values. It is up to the caller to decide # what to do. LOG.warning(_LW("IPMI get power state for node %(node_id)s returns the" " following details: %(detail)s"), {'node_id': driver_info['uuid'], 'detail': ret}) return states.ERROR
def _reboot(driver_info): """Reboot this node. If the power is off, turn it on. If the power is on, reset it. :param driver_info: the bmc access info for a node. :returns: power state POWER_ON, one of :class:`ironic.common.states`. :raises: IPMIFailure when the native ipmi call fails. :raises: PowerStateFailure when invalid power state is returned from ipmi. """ msg = _LW("IPMI power reboot failed for node %(node_id)s with the " "following error: %(error)s") try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) wait = CONF.ipmi.retry_timeout ret = ipmicmd.set_power('boot', wait) except pyghmi_exception.IpmiException as e: LOG.warning(msg % {'node_id': driver_info['uuid'], 'error': str(e)}) raise exception.IPMIFailure(cmd=str(e)) state = ret.get('powerstate') if state == 'on': return states.POWER_ON else: LOG.warning(msg % {'node_id': driver_info['uuid'], 'error': ret}) raise exception.PowerStateFailure(pstate=state)
def main(self): print colors.bold | "[ IPMIINFO ] ipmiip: {}, ipmiuser: {}, ipmipwd: {}".format( self._bmc, self._user, self._pwd) try: ipmicmd = ipmi_command.Command(bmc=self._bmc, userid=self._user, password=self._pwd) except Exception: print colors.warn | "[ ERROR ] failed: not connect" return if self.get_power: try: ret = ipmicmd.get_power() except Exception as e: print colors.warn | "[ ERROR ] failed: {}".format(e) else: print colors.green | "[ OK ] power is {}".format( ret.get("powerstate", "unknow")) else: try: ret = ipmicmd.set_power(self._action, wait=10) except Exception as e: print colors.warn | "[ ERROR ] failed: {}".format(e) else: status = ret.get("powerstate") if ret.get( "powerstate") else ret.get("pendingpowerstate") print colors.green | "[ OK ] power is {}".format( status, "unknow")
def start_ipmi_chassis_power_control(bmc_ip, bmc_username, bmc_password, power_status): ipmi_chassis_power_on_data = dict() ipmi_chassis_power_on_data['action'] = 'IPMI - Chassis Control' try: connection_object = command.Command(bmc=bmc_ip, userid=bmc_username, password=bmc_password) if connection_object: cmd_results = connection_object.set_power(power_status) if cmd_results and "error" not in cmd_results: ipmi_chassis_power_on_data['status'] = json_output_success_string ipmi_chassis_power_on_data['data'] = cmd_results # Return the error string if found in the results elif "error" in cmd_results: ipmi_chassis_power_on_data['status'] = json_output_failed_string ipmi_chassis_power_on_data['data'] = cmd_results else: ipmi_chassis_power_on_data['status'] = json_output_failed_string ipmi_chassis_power_on_data['data'] = json_ipmi_chassis_power_failed_string else: ipmi_chassis_power_on_data['status'] = json_output_failed_string ipmi_chassis_power_on_data['data'] = json_ipmi_failed_connecting_string return json.dumps(ipmi_chassis_power_on_data) except Exception as e: ipmi_chassis_power_on_data['status'] = json_output_error_string ipmi_chassis_power_on_data['data'] = "{}".format(e) return json.dumps(ipmi_chassis_power_on_data)
def main(): ''' Main function ''' args = get_args() if args['bootdev'] and args['power']: try: ipmicmd = command.Command(bmc=args['bmc'], userid=args['username'], password=args['password']) except gaierror: sys.exit('Unable to resolve provided BMC name') except pyghmi.exceptions.IpmiException: sys.exit('Invalid username or password') if args['power'] in ['on', 'reset', 'boot']: powerstate = 'on' elif args['power'] == 'status': power = get_power(ipmicmd) sys.exit('Power state: %s' % power) else: powerstate = 'off' bootdev = set_bootdev(ipmicmd, args['bootdev']) power = set_power(ipmicmd, args['power']) if not (bootdev == args['bootdev'] and power == powerstate): sys.exit( 'There was an error configuring the BMC. Please check connection and try again' ) else: print('BMC configured successfully') sys.exit()
def start_ipmi_network_eth0info_macaddress(bmc_ip, bmc_username, bmc_password): ipmi_network_eth0info_macaddress_data = dict() ipmi_network_eth0info_macaddress_data['action'] = 'IPMI - eth0 Network Mac Address' try: connection_object = command.Command(bmc=bmc_ip, userid=bmc_username, password=bmc_password) if connection_object: cmd_results = connection_object.raw_command(netfn=0x30, command=0x21, delay_xmit=None, retry=True, timeout=None) if cmd_results and "error" not in cmd_results: mac_address = '{0:02x}:{1:02x}:{2:02x}:{3:02x}:{4:02x}:{5:02x}:{6:02x}:{7:02x}:{8:02x}:{9:02x}'.format( *bytearray(cmd_results['data']))[12:] ipmi_network_eth0info_macaddress_data['status'] = json_output_success_string ipmi_network_eth0info_macaddress_data['data'] = mac_address # Return the error string if found in the results elif "error" in cmd_results: ipmi_network_eth0info_macaddress_data['status'] = json_output_failed_string ipmi_network_eth0info_macaddress_data['data'] = cmd_results else: ipmi_network_eth0info_macaddress_data['status'] = json_output_failed_string ipmi_network_eth0info_macaddress_data['data'] = json_ipmi_network_failed_string else: ipmi_network_eth0info_macaddress_data['status'] = json_output_failed_string ipmi_network_eth0info_macaddress_data['data'] = json_ipmi_failed_connecting_string return json.dumps(ipmi_network_eth0info_macaddress_data) except Exception as e: ipmi_network_eth0info_macaddress_data['status'] = json_output_error_string ipmi_network_eth0info_macaddress_data['data'] = "{}".format(e) return json.dumps(ipmi_network_eth0info_macaddress_data)
def set_boot_device(self, task, device, persistent=False): """Set the boot device for the task's node. Set the boot device to use on next reboot of the node. :param task: a task from TaskManager. :param device: the boot device, one of :mod:`ironic.common.boot_devices`. :param persistent: Boolean value. True if the boot device will persist to all future boots, False if not. Default: False. :raises: InvalidParameterValue if an invalid boot device is specified or required ipmi credentials are missing. :raises: MissingParameterValue when required ipmi credentials are missing. :raises: IPMIFailure on an error from pyghmi. """ if device not in self.get_supported_boot_devices(): raise exception.InvalidParameterValue(_( "Invalid boot device %s specified.") % device) driver_info = _parse_driver_info(task.node) try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) bootdev = _BOOT_DEVICES_MAP[device] ipmicmd.set_bootdev(bootdev, persist=persistent) except pyghmi_exception.IpmiException as e: LOG.error(_LE("IPMI set boot device failed for node %(node_id)s " "with the following error: %(error)s"), {'node_id': driver_info['uuid'], 'error': e}) raise exception.IPMIFailure(cmd=e)
def __init__(self, **kwargs): config = _get_config(**kwargs) self.o = command.Command(bmc=config['api_host'], userid=config['api_user'], password=config['api_pass'], port=config['api_port'], kg=config['api_kg'])
def main(): module = AnsibleModule( argument_spec=dict( name=dict(required=True), port=dict(default=623, type='int'), state=dict(required=True, choices=['on', 'off', 'shutdown', 'reset', 'boot']), user=dict(required=True, no_log=True), password=dict(required=True, no_log=True), key=dict(type='str', no_log=True), timeout=dict(default=300, type='int'), ), supports_check_mode=True, ) if command is None: module.fail_json(msg=missing_required_lib('pyghmi'), exception=PYGHMI_IMP_ERR) name = module.params['name'] port = module.params['port'] user = module.params['user'] password = module.params['password'] state = module.params['state'] timeout = module.params['timeout'] try: if module.params['key']: key = binascii.unhexlify(module.params['key']) else: key = None except Exception as e: module.fail_json(msg="Unable to convert 'key' from hex string.") # --- run command --- try: ipmi_cmd = command.Command(bmc=name, userid=user, password=password, port=port, kg=key) module.debug('ipmi instantiated - name: "%s"' % name) current = ipmi_cmd.get_power() if current['powerstate'] != state: response = { 'powerstate': state } if module.check_mode else ipmi_cmd.set_power(state, wait=timeout) changed = True else: response = current changed = False if 'error' in response: module.fail_json(msg=response['error']) module.exit_json(changed=changed, **response) except Exception as e: module.fail_json(msg=str(e))
def __init__(self, **kwargs): #cache_key = api_host + api_user + str(api_port) config = _get_config(**kwargs) self.o = command.Command(bmc=config['api_host'], userid=config['api_user'], password=config['api_pass'], port=config['api_port'], kg=config['api_key'])
def __init__(self, username=None, password=None, ip_address=None, port=BMC_PORT): self.o = command.Command(userid=username, password=password, bmc=ip_address, port=port)
def __init__(self, **kwargs): config = _get_config(**kwargs) self.o = command.Command( bmc=config["api_host"], userid=config["api_user"], password=config["api_pass"], port=config["api_port"], kg=config["api_kg"], )
def get_boot_device(self, task): """Get the current boot device for the task's node. Returns the current boot device of the node. :param task: a task from TaskManager. :raises: MissingParameterValue if required IPMI parameters are missing. :raises: IPMIFailure on an error from pyghmi. :returns: a dictionary containing: :boot_device: the boot device, one of :mod:`ironic.common.boot_devices` or None if it is unknown. :persistent: Whether the boot device will persist to all future boots or not, None if it is unknown. """ driver_info = task.node.driver_info driver_internal_info = task.node.driver_internal_info if (driver_info.get('ipmi_force_boot_device', False) and driver_internal_info.get('persistent_boot_device') and driver_internal_info.get('is_next_boot_persistent', True)): return { 'boot_device': driver_internal_info['persistent_boot_device'], 'persistent': True } driver_info = _parse_driver_info(task.node) response = {'boot_device': None} try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) ret = ipmicmd.get_bootdev() # FIXME(lucasagomes): pyghmi doesn't seem to handle errors # consistently, for some errors it raises an exception # others it just returns a dictionary with the error. if 'error' in ret: raise pyghmi_exception.IpmiException(ret['error']) except pyghmi_exception.IpmiException as e: LOG.error( _LE("IPMI get boot device failed for node %(node_id)s " "with the following error: %(error)s"), { 'node_id': driver_info['uuid'], 'error': e }) raise exception.IPMIFailure(cmd=e) response['persistent'] = ret.get('persistent') bootdev = ret.get('bootdev') if bootdev: response['boot_device'] = next( (dev for dev, hdev in _BOOT_DEVICES_MAP.items() if hdev == bootdev), None) return response
def imm_connect(self, host, username, password): try: connection = command.Command(bmc=host, userid=username, password=password) except pyghmi.exceptions.IpmiException: raise exc.AuthException assert connection is not None self.connection = connection
def _create_ipmi_connection(self): # Do not use the (custom) ipaddress for the host. Use the management board # address instead credentials = self._credentials self._logger.debug("Connecting to %s:623 (User: %s, Privlevel: 2)" % (self._ipaddress, credentials["username"])) return ipmi_cmd.Command(bmc=self._ipaddress, userid=credentials["username"], password=credentials["password"], privlevel=2)
def _command(self, bmc): try: self.ipmi_cmd = ipmi_command.Command( bmc=bmc['ipv4'], userid=bmc['userid'], password=bmc['password']) except pyghmi_exception.IpmiException as exc: self.log.error( 'IPMI \'Command\' failed - Rack: %s - IP: %s, %s' % (bmc['rack_id'], bmc['ipv4'], str(exc))) sys.exit(1)
def __init__(self, log, inv_file): inv = Inventory(log, inv_file) for rack_id, ipv4, _userid, _password in inv.yield_ipmi_access_info(): ipmi_cmd = ipmi_command.Command(bmc=ipv4, userid=_userid, password=_password) try: inv = ipmi_cmd.get_net_configuration(channel=None, gateway_macs=False) except pyghmi_exception.IpmiException as error: log.error(IPMI_GET_ERR_MSG % (rack_id, ipv4, str(error))) sys.exit(1) match = re.search('^(.+?)/', inv['ipv4_address']) inv_ipv4_address_no_mask = match.group(1) # Check that IPMI port is not set to Static if inv['ipv4_configuration'] == STATIC: try: raise Exception() except: log.error(DHCP_ERR_MSG % (STATIC, rack_id, inv_ipv4_address_no_mask, inv['mac_address'])) sys.exit(1) # Compare ipv4 address on IPMI port versus inventory file if inv_ipv4_address_no_mask != ipv4: try: raise Exception() except: log.error(IPV4_ERR_MSG % (rack_id, inv_ipv4_address_no_mask, ipv4, inv['mac_address'])) sys.exit(1) # Compare mac address on IPMI port versus inventory file try: ipmi_cmd.set_net_configuration( ipv4_address=inv['ipv4_address'], ipv4_configuration='Static', ipv4_gateway=inv['ipv4_gateway'], channel=None) log.info(IPMI_SET_MSG % (STATIC, rack_id, ipv4, inv['mac_address'])) except pyghmi_exception.IpmiException as error: log.error( IPMI_SET_ERR_MSG % (STATIC, rack_id, ipv4, inv['mac_address'], str(error))) sys.exit(1)
def __init__(self, log, inv_file): self.inv = Inventory(log, inv_file) self.log = log for _, _, self.group, self.index, self.node in \ self.inv.yield_nodes(): ipmi_cmd = ipmi_command.Command( bmc=self.node[self.inv.INV_IPV4_IPMI], userid=self.node[self.inv.INV_USERID_IPMI], password=self.node[self.inv.INV_PASSWORD_IPMI]) components = [] try: for desc in ipmi_cmd.get_inventory_descriptions(): components.append(desc) except ipmi_exc.IpmiException as exc: self._log_ipmi_exception(exc) continue self.comp_name = self.IPMI_SYSTEM_FIRMWARE if self.comp_name in components: try: self.comp_value = ipmi_cmd.get_inventory_of_component( self.comp_name) self._get_ipmi_architecture() self._get_ipmi_field(self.IPMI_HARDWARE_VERSION) except ipmi_exc.IpmiException as exc: self._log_ipmi_exception(exc) self.comp_name = self.IPMI_SYSTEM if self.comp_name in components: try: self.comp_value = ipmi_cmd.get_inventory_of_component( self.comp_name) self._get_ipmi_field(self.IPMI_PRODUCT_NAME) self._get_ipmi_field(self.IPMI_CHASSIS_PART_NUMBER) self._get_ipmi_field(self.IPMI_CHASSIS_SERIAL_NUMBER) self._get_ipmi_field(self.IPMI_MODEL) self._get_ipmi_field(self.IPMI_SERIAL_NUMBER) except ipmi_exc.IpmiException as exc: self._log_ipmi_exception(exc) self.comp_name = self.IPMI_NODE1 if self.comp_name in components: try: self.comp_value = ipmi_cmd.get_inventory_of_component( self.comp_name) self._get_ipmi_field(self.IPMI_CHASSIS_PART_NUMBER) self._get_ipmi_field(self.IPMI_CHASSIS_SERIAL_NUMBER) except ipmi_exc.IpmiException as exc: self._log_ipmi_exception(exc)
def open(self) -> None: self._logger.debug( "Connecting to %s:623 (User: %s, Privlevel: 2)", self.address or "local", self.username or "no user", ) # Performance: See header. import pyghmi.ipmi.command as ipmi_cmd # type: ignore[import] self._command = ipmi_cmd.Command( bmc=self.address, userid=self.username, password=self.password, privlevel=2, )
def initialize_ipmi_session(self): """ Initialize command object with IPMI details """ attempts = 0 while attempts < 5: try: ipmi_object = command.Command(self.ipmi_ip, self.user_id, self.password) except IpmiException as e: print(e.args[0]) logger.warning( "IPMI command failed, retrying after 15 seconds...") sleep(15) attempts = attempts + 1 continue return ipmi_object
def main(): module = AnsibleModule( argument_spec=dict( name=dict(required=True), port=dict(default=623, type='int'), state=dict(required=True, choices=['on', 'off', 'shutdown', 'reset', 'boot']), user=dict(required=True, no_log=True), password=dict(required=True, no_log=True), timeout=dict(default=300, type='int'), ), supports_check_mode=True, ) if command is None: module.fail_json(msg='the python pyghmi module is required') name = module.params['name'] port = module.params['port'] user = module.params['user'] password = module.params['password'] state = module.params['state'] timeout = module.params['timeout'] # --- run command --- try: ipmi_cmd = command.Command(bmc=name, userid=user, password=password, port=port) module.debug('ipmi instantiated - name: "%s"' % name) current = ipmi_cmd.get_power() if current['powerstate'] != state: response = { 'powerstate': state } if module.check_mode else ipmi_cmd.set_power(state, wait=timeout) changed = True else: response = current changed = False if 'error' in response: module.fail_json(msg=response['error']) module.exit_json(changed=changed, **response) except Exception as e: module.fail_json(msg=str(e))
def __init__(self, host_list, interval): threading.Thread.__init__(self) self.interval = interval # Polling interval in seconds self.server_connection_list = [] self.failed_connection_list = [] self.stopped = False for host in host_list: try: ipmi = command.Command(bmc=host.hostname, userid=host.userid, password=host.password) server_connection = ServerConnection(ipmi, host.unique_id) self.server_connection_list.append(server_connection) print(host.hostname + " - ipmi connection established") except: self.failed_connection_list.append(host.unique_id) print(host.hostname + " - ipmi connection failed")
def callFunc(req, cmd, retry): try: retry = retry + 1 error(req.uuid + ": Retry Attempt - " + str(retry)) # error(retry) cmd = command.Command(bmc=ipmi_host, userid=ipmi_user, password=ipmi_pass) result = func(req, cmd) error(result) except IpmiException, e: if retry != 60: time.sleep(30) result = callFunc(req, cmd, retry) else: result = fail(msg=str(e))
def _send_raw(driver_info, raw_bytes): """Send raw bytes to the BMC.""" netfn, command, data = _parse_raw_bytes(raw_bytes) LOG.debug("Sending raw bytes %(bytes)s to node %(node_id)s", {'bytes': raw_bytes, 'node_id': driver_info['uuid']}) try: ipmicmd = ipmi_command.Command(bmc=driver_info['address'], userid=driver_info['username'], password=driver_info['password']) ipmicmd.xraw_command(netfn, command, data=data) except pyghmi_exception.IpmiException as e: msg = (_("IPMI send raw bytes '%(bytes)s' failed for node %(node_id)s" " with the following error: %(error)s") % {'bytes': raw_bytes, 'node_id': driver_info['uuid'], 'error': e}) LOG.error(msg) raise exception.IPMIFailure(msg)
def start_ipmi_boot_setnextboot(bmc_ip, bmc_username, bmc_password, boot_option, persist=False, uefiboot=False): ipmi_boot_setnextboot_data = dict() ipmi_boot_setnextboot_data['action'] = 'IPMI - Configure boot' try: connection_object = command.Command(bmc=bmc_ip, userid=bmc_username, password=bmc_password) if connection_object: cmd_results = connection_object.set_bootdev(bootdev=boot_option, persist=persist, uefiboot=uefiboot) if cmd_results and "error" not in cmd_results: ipmi_boot_setnextboot_data[ 'status'] = json_output_success_string ipmi_boot_setnextboot_data['data'] = cmd_results # Return the error string if found in the results elif "error" in cmd_results: ipmi_boot_setnextboot_data[ 'status'] = json_output_failed_string ipmi_boot_setnextboot_data['data'] = cmd_results else: ipmi_boot_setnextboot_data[ 'status'] = json_output_failed_string ipmi_boot_setnextboot_data[ 'data'] = json_ipmi_boot_setnextboot_failed_string else: ipmi_boot_setnextboot_data['status'] = json_output_failed_string ipmi_boot_setnextboot_data[ 'data'] = json_ipmi_failed_connecting_string return json.dumps(ipmi_boot_setnextboot_data) except Exception as e: ipmi_boot_setnextboot_data['status'] = json_output_error_string ipmi_boot_setnextboot_data['data'] = "{}".format(e) return json.dumps(ipmi_boot_setnextboot_data)