def handle(self, hostname, *args, **options): validate_host(hostname) logger.info("Powercycling %s via HP iLO. %s", hostname, options) username = options.get('login', None) or settings.ILO_USERNAME password = options.get('password', None) or settings.ILO_PASSWORD ilo = hpilo.Ilo(hostname, login=username, password=password, timeout=options['timeout']) power_status = ilo.get_host_power_status() logger.debug("Got power status %s for ilo server %s.", power_status, hostname) try: ilo.reset_server() logger.debug("Soft reset of ilo server %s complete.", hostname) except Exception as error: logger.debug("clean powercycle of ilo server %s failed with error: %s", hostname, error) ilo.set_host_power(host_power=False) logger.debug("hard shutdown of ilo sever %s complete.", hostname) logger.debug("Power is off, waiting %d seconds before turning it back on.", options['delay']) time.sleep(options['delay']) ilo.set_host_power(host_power=True) logger.info("Powercycle of %s completed.", hostname)
def oob_powercycle(self, oob_username=None, oob_password=None): oob_return = "Unknown power status" ilo = hpilo.Ilo(self.get('oob_ip'), oob_username, oob_password) oob_return = ilo.reset_server() oob_return = "OK" return oob_return
def job(ip): #time.sleep(interval) username = "******" password = "******" print(ip, username, "password") ilo = hpilo.Ilo(ip, username, password) b = False try: print(ip, "start cold boot") #ilo.cold_boot_server() b = True #print(b) pass except Exception as identifier: if (identifier != 'The read operation timed out'): b = True #print(b) pass finally: if (b): print(ip, " cold boot successful") else: print(ip, " cold boot failed") log(ip + " " + ("cold boot successful" if b else "cold boot failed")) pass
def _login(delay=False, **kwargs): """ Helper function for handling iLO credentials and establishing the connection. """ if all(k in kwargs for k in ('login', 'password', 'hostname')): creds = { 'login': config['login'], 'password': config['password'], 'hostname': config['hostname'] } elif 'profile' in kwargs: # use the host profile profile = __salt__['config.option'](kwargs['profile']) creds = { 'login': profile['login'], 'password': profile['password'], 'hostname': profile['hostname'], } else: # Finally use the minion configuration creds = { 'login': __salt__['config.option']('hpilo.login'), 'password': __salt__['config.option']('hpilo.password'), 'hostname': __salt__['config.option']('hpilo.hostname'), } return hpilo.Ilo(**creds, delayed=delay)
def __init__(self, ops, data): super().__init__(ops, data) global FABRIC_PATCHED if not FABRIC_PATCHED: Connection.open_orig = Connection.open Connection.open = unsafe_open FABRIC_PATCHED = True # Load configuration config = get_config() ssh_user = config.get('ssh', 'user', fallback=None) ssh_key_file = config.get('ssh', 'ssh_key_file', fallback=None) connect_kwargs = { 'key_filename': ssh_key_file } if ssh_key_file else None ilo_user = config.get('ilo', 'user', fallback=None) ilo_password = config.get('ilo', 'password', fallback=None) # Setup SSH connection self._connection = Connection(self['name'], user=ssh_user, connect_kwargs=connect_kwargs) # Setup ILO connection ilo_address = self['name'].split('.') ilo_address.insert(1, 'ilom') ilo_address = '.'.join(ilo_address) self._ilo = hpilo.Ilo(ilo_address, login=ilo_user, password=ilo_password) self.vms_with_shutdown_policy = []
def __new__(cls, name, bases, attrs): attrs['ilos'] = {} config = ConfigParser.ConfigParser() config.read(os.path.expanduser(os.path.join('~', '.ilo.conf'))) login = config.get('ilo', 'login') password = config.get('ilo', 'password') methods = [] for attr in list(attrs.keys()): if attr.startswith('test_') and callable(attrs[attr]): attrs['_' + attr] = attrs.pop(attr) methods.append(attr[5:]) for section in config.sections(): if not section.startswith('test '): continue key = section.split()[1] hostname = config.get(section, 'ilo') ilo = hpilo.Ilo(hostname, login, password) ilo.firmware_version = firmware_cache[ilo] if not ilo.protocol: ilo.protocol = hpilo.ILO_RAW if ilo.firmware_version[ 'management_processor'].lower() in ( 'ilo', 'ilo2') else hpilo.ILO_HTTP ilo.save_response = os.path.join(testroot, 'hpilo_test_debug_output') attrs['ilos'][key] = ilo for method in methods: fname = re.sub('[^a-zA-Z0-9_]', '_', 'test_%s_%s' % (key, method)) attrs[fname] = eval( "lambda self: self._test_%s(self.ilos['%s'])" % (method, key)) return super(IloTestCaseMeta, cls).__new__(cls, name, bases, attrs)
def get_oob_netmacs(self, oob_username=None, oob_password=None): ilo = hpilo.Ilo(self.get('oob_ip'), oob_username, oob_password) data = ilo.get_host_data() for item in data: if 'MAC' in item: self.netmac[item['Port']]=item['MAC'] return self.netmac
def get_temp(host,ilo_user,ilo_pass): ilo = hpilo.Ilo(host,ilo_user,ilo_pass) health = ilo.get_embedded_health() #get the current Inlet Ambient temp from the sensor, in Celcius temp_c = health['temperature']['01-Inlet Ambient']['currentreading'][0] #convert to fahrenheit temp_f = int(temp_c) * 9/5 + 32 return temp_f
def get_the_data_subType(self, dev, type): try: ipaddress = dev.pluginProps.get('ipaddress', "") username = dev.pluginProps.get('username', "") password = dev.pluginProps.get('password', "") self.logger.debug(u"Connecting to IP " + unicode(ipaddress) + " with username" + unicode(username) + " and password:"******"health": health = ilo.get_embedded_health() self.process_data(dev, health, type) elif type == "fw_version": fw_version = ilo.get_fw_version() self.process_data(dev, fw_version, type) elif type == "poweron": timeon = ilo.get_server_power_on_time() self.logger.debug("Timeon:" + unicode(timeon)) self.process_data(dev, timeon, type) elif type == "hostdata": host_data = ilo.get_host_data() self.process_data(dev, host_data, type) elif type == "power": power_readings = ilo.get_power_readings() self.process_data(dev, power_readings, "power") elif type == "power_status": power_status = ilo.get_host_power_status() self.process_data(dev, power_status, "power_status") return info except hpilo.IloCommunicationError: self.logger.exception("Error communicating with HP iLO") dev.updateStateOnServer('deviceIsOnline', value=False) return None except hpilo.IloLoginFailed: self.logger.info( "Login to iLO failed - check Password Username security settings" ) dev.updateStateOnServer('deviceIsOnline', value=False) return None except hpilo.IloFeatureNotSupported: self.logger.debug("Some Features not supported. Ignored.") pass except Exception: self.logger.exception("Exception Found") dev.updateStateOnServer('deviceIsOnline', value=False) return None
def oob_powerup(self, oob_username=None, oob_password=None): oob_return = "Unknown" ilo = hpilo.Ilo(self.get('oob_ip'), oob_username, oob_password) oob_return = ilo.set_host_power(host_power=True) oob_return = "OK" return oob_return
def ilo3_128(hostname, login, password, ilo3): print('[+] Upgrading ' + hostname + ' to v1.28') ilobin = 'ilo3_128.bin' ilo = hpilo.Ilo(hostname, login, password) ilo.update_rib_firmware(filename='ilobins/' + ilobin, progress=print_progress) print('\n[*] Waiting 2 Minutes for iLO to reset before upgrading to ' + ilo3) time.sleep(120) return
def login(self): # signal.signal(signal.SIGALRM,self.signal_handler) # signal.alarm(10) self.ilo = hpilo.Ilo(self.server, self.username, self.password) try: self.ilo.get_fw_version() except Exception as e: return {'status': 0, 'msg': e} return {'status': 1, 'msg': 'login ok'}
def connect(host, user, pwd): if not (host or user or pwd): print("Could not connect! Parameters were not all provided") ilo = hpilo.Ilo(host, login=user, password=pwd, timeout=120, port=443, protocol=None) return ilo
def update(self): """Get the latest data from HP ILO.""" import hpilo try: self.data = hpilo.Ilo( hostname=self._host, login=self._login, password=self._password, port=self._port) except (hpilo.IloError, hpilo.IloCommunicationError, hpilo.IloLoginFailed) as error: raise ValueError("Unable to init HP ILO, %s", error)
def spp(target, login, password, url, key): ilo = hpilo.Ilo(target, login, password) print('[+] Applying SPP to ' + target) #check if anything mounted get_vm_status(device='CDROM') #if not install the key try: media_state = (ilo.get_vm_status(device='CDROM')['image_inserted']) #print media_state except: ilo.activate_license(key) media_state = (ilo.get_vm_status(device='CDROM')['image_inserted']) print('[+] iLO Advanced was not present but has been applied to ' + target) #dismount anything that might already be there eject_virtual_media(device='cdrom') if media_state == 'YES': ilo.eject_virtual_media(device='cdrom') #mount cdrom to url insert_virtual_media(cdrom, url) try: ilo.insert_virtual_media('cdrom', url) except: print('******************************') print('[-] Could not insert media on ' + target) print('******************************') return #set boot set_vm_status(device='cdrom', boot_option='boot_once', write_protect=True try: ilo.set_vm_status(device='cdrom', boot_option='boot_once', write_protect=True) except: print('******************************') print('[-] Could not set boot status on ' + target) print('******************************') return #check if server is on get_host_power_status() power = ilo.get_host_power_status() #print power #if off boot server press_pwr_btn() if power == 'OFF': ilo.press_pwr_btn() elif power == 'ON': print('[-] ' + target + ' is currently powered on') print(' Attempting ACPI shutdown') ilo.press_pwr_btn() print('[*] Waiting 60 seconds') if ilo.get_host_power_status() == 'OFF': print('[-] ACPI shutdown unsuccessful') print('[!] Forcing cold boot') ilo.cold_boot_server()
def get_ilo(self): """ Get an instance of hpilo.Ilo() that represents this host. Example Usage: model_ilo = IloHost(hostname='x', login='******', password='******') actual_ilo = model_ilo.get_ilo() actual_ilo.get_host_data() """ ilo = hpilo.Ilo(hostname=self.address, login=self.username, password=self.password) return ilo
def AddIloUser(args): ilo_ip, username, password = args ilo = hpilo.Ilo(ilo_ip, username, password) ilo.add_user(virtual_media_priv=False, reset_server_priv=False, config_ilo_priv=True, user_login="******", remote_cons_priv=False, admin_priv=False, password="******", user_name="username")
def main(hosts): parser = argparse.ArgumentParser(description='Do the stuff.') parser.add_argument('--os_username', type=str, default=os.environ.get('OS_USERNAME'), help='Ironic username') parser.add_argument('--os_tenant', type=str, default=os.environ.get('OS_TENANT_NAME'), help='Ironic tenant name') parser.add_argument('--os_password', type=str, default=os.environ.get('OS_PASSWORD'), help='Ironic password') parser.add_argument('--os_auth_url', type=str, default=os.environ.get('OS_AUTH_URL'), help='Ironic auth URL') args = parser.parse_args() if (not args.os_username or not args.os_tenant or not args.os_password or not args.os_auth_url): print('You must supply all details') parser.print_help() sys.exit(1) ironic = get_ironic_client(args.os_username, args.os_password, args.os_auth_url, args.os_tenant) clients = {} import jiocloud.enroll mac_to_uuid = {} for _port in ironic.port.list(): mac_to_uuid[_port.address.lower()] = _port.uuid for host in ironic.node.list(): node_obj = ironic.node.get(host.uuid) if node_obj.properties['cpus'] != 24: continue iloconn = hpilo.Ilo(node_obj.driver_info['ipmi_address'], node_obj.driver_info['ipmi_username'], node_obj.driver_info['ipmi_password']) host_data = jiocloud.enroll.get_host_data(iloconn) macs = jiocloud.enroll.extract_macs( jiocloud.enroll.extract_net_info(host_data)) mac = macs['3'] try: if mac not in mac_to_uuid: continue ironic.port.delete(mac_to_uuid[mac]) except HTTPServiceUnavailable, e: print e
def node_status_irs(ilo_ip): logger = logging.getLogger("node_status_irs") try: ilo = hpilo.Ilo(ilo_ip, ilo_username, ilo_password) ilo_irs_settings = ilo.get_ers_settings() logger.info("NODE_STATUS: checking the status of %s", ilo_ip) return json_response(200, status='success', irs_settings=ilo_irs_settings) except Exception as err: return json_response(500, status='error', ilo_response=str(err))
def get_oob_powerstate(self, oob_username=None, oob_password=None): ilo = hpilo.Ilo(self.get('oob_ip'), oob_username, oob_password) oob_return = ilo.get_host_power_status() # standardize the response if "ON" in oob_return: oob_return = "ON" if "OFF" in oob_return: oob_return = "OFF" return oob_return
def add_user(hostname, ilo_username, ilo_password, username, password): ilo = hpilo.Ilo(hostname, ilo_username, ilo_password) print('Connected!') print username, password # add the the user ilo.add_user(user_name=username, user_login=username, password=password, admin_priv=True) print('Added ', username)
def connect_hp_server(host,user,password): """ This function wil make connection to HP standalone or blade server by hpilo """ ilo = hpilo.Ilo(host,user,password) host_data = ilo.get_host_data() server_lst = [] server = {'name': ilo.get_server_name(), 'product_name':host_data[1]['Product Name'], 'serial':host_data[1]['Serial Number'],'ip_address':ilo.get_network_settings()['ip_address']} server_lst.append(server) return server_lst
def GetIloLogs(args): ilo_ip, username, password = args ilo = hpilo.Ilo(ilo_ip, username, password) iml_logs = ilo.get_server_event_log() logfile_url = "/data/hpilo_log/" + ilo_ip with open(logfile_url, 'a+') as logfile: for iml_log in iml_logs: format_log = iml_log['last_update'] + ' ' + ilo_ip + ' ' + iml_log['severity'] + \ ' ' + iml_log['class'] + ' ' + iml_log['description'] + '\n' if not CheckIfExist(logfile_url, format_log): logfile.write(format_log) with open(newlogfile_url, 'a') as newlog: iml_log['host'] = ilo_ip newlog.write(str(iml_log) + '\n')
def ilogo(hostname, login, password, ilo2, ilo3, ilo4): # Set the iLo variable ilo = hpilo.Ilo(hostname, login, password) #Check current iLO version try: ilo_fw_version = ilo.get_fw_version() except: print('[-] Cannot connect to ' + hostname) return ilo_version = ilo_fw_version['management_processor'] firmware_version = ilo_fw_version['firmware_version'] print('[*] Checking ' + hostname) print('[*] iLO type: ' + ilo_version) print('[*] Current firmware: ' + firmware_version) checkilo = ilo_version.lower() + '_' + firmware_version.replace( '.', '') + '.bin' #print (checkilo) if checkilo == ilo2 or checkilo == ilo3 or checkilo == ilo4: print('[+] Current firmare at target version') else: print('[-] Firmware will be updated') if ilo_version == 'iLO2': ilobin = ilo2 elif ilo_version == 'iLO3': # Problems upgrading from versions before 1.28 # if ilo3 lower than 1.28 detected, force upgrade to 1.28 first if float(firmware_version) < 1.28: print('[-] Current version too old.') print(' ' + hostname + ' MUST upgrade to v1.28 before proceeding') ilo3_128(hostname, login, password, ilo3) ilobin = ilo3 elif ilo_version == 'iLO4': ilobin = ilo4 print('[+] Updating ' + hostname) try: ilo.update_rib_firmware(filename='ilobins/' + ilobin, progress=print_progress) except: print('\n[-] An error occured whilst updating ' + hostname) print('\n Please try this host again') print('')
def update(self): """Get the latest data from HP iLO.""" try: self.data = hpilo.Ilo( hostname=self._host, login=self._login, password=self._password, port=self._port, ) except ( hpilo.IloError, hpilo.IloCommunicationError, hpilo.IloLoginFailed, ) as error: raise ValueError(f"Unable to init HP ILO, {error}") from error
def del_irs(ilo_ip): logger = logging.getLogger("del_irs") # Basic validation if ilo_ip is None: abort(404) try: ilo = hpilo.Ilo(ilo_ip, ilo_username, ilo_password) ilo_disable_ers = ilo.disable_ers() logger.info( "DEL_IRS: User just disconnected %s node from its IRS instance.", ilo_ip) return json_response(200, status='success', irs_disable_ers=ilo_disable_ers) except Exception as err: return json_response(500, status='error', ilo_response=str(err))
def main(hosts): parser = argparse.ArgumentParser(description='Do the stuff.') parser.add_argument('--os_username', type=str, default=os.environ.get('OS_USERNAME'), help='Ironic username') parser.add_argument('--os_tenant', type=str, default=os.environ.get('OS_TENANT_NAME'), help='Ironic tenant name') parser.add_argument('--os_password', type=str, default=os.environ.get('OS_PASSWORD'), help='Ironic password') parser.add_argument('--os_auth_url', type=str, default=os.environ.get('OS_AUTH_URL'), help='Ironic auth URL') args = parser.parse_args() if (not args.os_username or not args.os_tenant or not args.os_password or not args.os_auth_url): print('You must supply all details') parser.print_help() sys.exit(1) ironic = get_ironic_client(args.os_username, args.os_password, args.os_auth_url, args.os_tenant) clients = {} import jiocloud.enroll for host in ironic.node.list(): node_obj = ironic.node.get(host.uuid) if node_obj.properties['cpus'] != 24: continue iloconn = hpilo.Ilo(node_obj.driver_info['ipmi_address'], node_obj.driver_info['ipmi_username'], node_obj.driver_info['ipmi_password']) host_data = jiocloud.enroll.get_host_data(iloconn) macs = jiocloud.enroll.extract_macs( jiocloud.enroll.extract_net_info(host_data)) for idx in '3 4'.split(' '): try: ironic.port.create(address=macs[idx], node_uuid=host.uuid) except HTTPConflict, e: print e
def main(hosts): parser = argparse.ArgumentParser(description='Do the stuff.') parser.add_argument('--os_username', type=str, default=os.environ.get('OS_USERNAME'), help='Ironic username') parser.add_argument('--os_tenant', type=str, default=os.environ.get('OS_TENANT_NAME'), help='Ironic tenant name') parser.add_argument('--os_password', type=str, default=os.environ.get('OS_PASSWORD'), help='Ironic password') parser.add_argument('--os_auth_url', type=str, default=os.environ.get('OS_AUTH_URL'), help='Ironic auth URL') args = parser.parse_args() if (not args.os_username or not args.os_tenant or not args.os_password or not args.os_auth_url): print('You must supply all details') parser.print_help() sys.exit(1) ironic = get_ironic_client(args.os_username, args.os_password, args.os_auth_url, args.os_tenant) clients = {} for host in ironic.node.list(): node_obj = ironic.node.get(host.uuid) client = hpilo.Ilo(node_obj.driver_info['ipmi_address'], node_obj.driver_info['ipmi_username'], node_obj.driver_info['ipmi_password']) sn = [ x for x in client.get_host_data(decoded_only=True) if x['type'] == 226 ][0]['Serial Number'].strip() print '%s has serial number %s. Storing that in Ironic.' % (host.uuid, sn) ironic.node.update(node_obj.uuid, [{ 'op': 'add', 'path': '/properties/serial_number', 'value': sn }])
def add_irs(ilo_ip): logger = logging.getLogger("add_irs") data = json.loads(request.data) if not 'ers_destination_url' in data: abort(400) else: ers_destination_url = data['ers_destination_url'] try: ilo = hpilo.Ilo(ilo_ip, ilo_username, ilo_password) ilo_ers_irs_connect = ilo.set_ers_irs_connect( data['ers_destination_url'], ers_destination_port) logger.info( "ADD_IRS: User just connected %s node to %s IRS instance.", ilo_ip, ers_destination_url) return json_response(200, status='success', ilo_ers_irs_connect=ilo_ers_irs_connect) except hpilo.IloError as ilo_error: return json_response(500, status='error', ilo_response=str(ilo_error))
def main(): module = AnsibleModule(argument_spec=dict( host=dict(type='str', required=True), login=dict(type='str', default='Administrator'), password=dict(type='str', default='admin', no_log=True), media=dict(type='str', choices=[ 'cdrom', 'floppy', 'rbsu', 'hdd', 'network', 'normal', 'usb' ]), image=dict(type='str'), state=dict(type='str', default='boot_once', choices=[ 'boot_always', 'boot_once', 'connect', 'disconnect', 'no_boot', 'poweroff' ]), force=dict(type='bool', default=False), ssl_version=dict( type='str', default='TLSv1', choices=['SSLv3', 'SSLv23', 'TLSv1', 'TLSv1_1', 'TLSv1_2']), )) if not HAS_HPILO: module.fail_json(msg='The hpilo python module is required') host = module.params['host'] login = module.params['login'] password = module.params['password'] media = module.params['media'] image = module.params['image'] state = module.params['state'] force = module.params['force'] ssl_version = getattr( hpilo.ssl, 'PROTOCOL_' + module.params.get('ssl_version').upper().replace('V', 'v')) ilo = hpilo.Ilo(host, login=login, password=password, ssl_version=ssl_version) changed = False status = {} power_status = 'UNKNOWN' if media and state in ('boot_always', 'boot_once', 'connect', 'disconnect', 'no_boot'): # Workaround for: Error communicating with iLO: Problem manipulating EV try: ilo.set_one_time_boot(media) except hpilo.IloError: time.sleep(60) ilo.set_one_time_boot(media) # TODO: Verify if image URL exists/works if image: ilo.insert_virtual_media(media, image) changed = True if media == 'cdrom': ilo.set_vm_status('cdrom', state, True) status = ilo.get_vm_status() changed = True elif media in ('floppy', 'usb'): ilo.set_vf_status(state, True) status = ilo.get_vf_status() changed = True # Only perform a boot when state is boot_once or boot_always, or in case we want to force a reboot if state in ('boot_once', 'boot_always') or force: power_status = ilo.get_host_power_status() if not force and power_status == 'ON': module.fail_json( msg= 'HP iLO (%s) reports that the server is already powered on !' % host) if power_status == 'ON': ilo.warm_boot_server() # ilo.cold_boot_server() changed = True else: ilo.press_pwr_btn() # ilo.reset_server() # ilo.set_host_power(host_power=True) changed = True elif state in ('poweroff'): power_status = ilo.get_host_power_status() if not power_status == 'OFF': ilo.hold_pwr_btn() # ilo.set_host_power(host_power=False) changed = True module.exit_json(changed=changed, power=power_status, **status)