def power_on_node(self, node): logger.debug("Powering on " + node.name) urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) drac_client = DRACClient(node.idrac_ip, self.settings.ipmi_user, self.settings.ipmi_pwd) if "POWER_OFF" in drac_client.get_power_state(): drac_client.set_power_state('POWER_ON')
def power_off_cluster_nodes(self): # Power off all control & compute nodes urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) logger.info("Powering off Control & Compute nodes") for node in ( self.settings.controller_nodes + self.settings.compute_nodes): logger.debug("powering off " + node.name ) drac_client = DRACClient(node.idrac_ip, self.settings.ipmi_user, self.settings.ipmi_pwd) if "POWER_ON" in drac_client.get_power_state(): drac_client.set_power_state('POWER_OFF')
def main(): parser = argparse.ArgumentParser( description="Queries an iDRAC to determine if it is ready to process " "commands.", formatter_class=argparse.ArgumentDefaultsHelpFormatter) ArgHelper.add_ip_service_tag(parser) ArgHelper.add_instack_arg(parser) LoggingHelper.add_argument(parser) args = parser.parse_args() LoggingHelper.configure_logging(args.logging_level) ip_service_tag = args.ip_service_tag node_definition = args.node_definition return_code = 0 try: node = CredentialHelper.get_node_from_instack(ip_service_tag, node_definition) if not node: raise ValueError("Unable to find {} in {}".format( ip_service_tag, node_definition)) drac_ip = node["pm_addr"] drac_user = node["pm_user"] drac_password = node["pm_password"] drac_client = DRACClient(drac_ip, drac_user, drac_password) ready = drac_client.is_idrac_ready() if ready: LOG.info("iDRAC is ready") else: return_code = 1 LOG.info("iDRAC is NOT ready") except: # noqa: E501 LOG.exception("An exception occurred:") return_code = 2 sys.exit(return_code)
def config_idrac(instack_lock, ip_service_tag, node_definition=Constants.INSTACKENV_FILENAME, model_properties=Utils.get_model_properties( Constants.MODEL_PROPERTIES_FILENAME), pxe_nic=None, password=None, skip_nic_config=False): node = CredentialHelper.get_node_from_instack(ip_service_tag, node_definition) if not node: raise ValueError("Unable to find {} in {}".format( ip_service_tag, node_definition)) drac_ip = node["pm_addr"] drac_user = node["pm_user"] drac_password = node["pm_password"] ironic_driver = node["pm_type"] if ironic_driver != "idrac": LOG.info("{} is using the {} driver. No iDRAC configuration is " "possible.".format(ip_service_tag, ironic_driver)) if pxe_nic: LOG.warning("Ignoring specified PXE NIC ({})".format(pxe_nic)) if password: LOG.warning("Ignoring specified password") return drac_client = DRACClient(drac_ip, drac_user, drac_password) reset_idrac(drac_client, ip_service_tag) # Clear out any pending jobs in the job queue and fix the condition where # there are no pending jobs, but the iDRAC thinks there are clear_job_queue(drac_client, ip_service_tag) if skip_nic_config: target_boot_mode = BootModeHelper.get_boot_mode(drac_client) elif BootModeHelper.is_boot_order_flexibly_programmable(drac_client): target_boot_mode = boot_mode_helper.DRAC_BOOT_MODE_UEFI else: target_boot_mode = boot_mode_helper.DRAC_BOOT_MODE_BIOS config_boot_mode(drac_client, ip_service_tag, node, target_boot_mode) job_ids = list() reboot_required = False pxe_nic_fqdd = get_pxe_nic_fqdd(pxe_nic, model_properties, drac_client) if skip_nic_config: provisioning_mac = get_nic_mac_address(drac_client, pxe_nic_fqdd) LOG.info("Skipping NIC configuration") else: # Configure the NIC port to PXE boot or not reboot_required_nic, nic_job_ids, provisioning_mac = \ configure_nics_boot_settings(drac_client, ip_service_tag, pxe_nic_fqdd, node, target_boot_mode) reboot_required = reboot_required or reboot_required_nic if nic_job_ids: job_ids.extend(nic_job_ids) # Do initial idrac configuration reboot_required_idrac, idrac_job_id = config_idrac_settings( drac_client, ip_service_tag, password, node) reboot_required = reboot_required or reboot_required_idrac if idrac_job_id: job_ids.append(idrac_job_id) # If we need to reboot, then add a job for it if reboot_required: LOG.info("Rebooting {} to apply configuration".format(ip_service_tag)) job_id = drac_client.create_reboot_job() job_ids.append(job_id) success = True if job_ids: drac_client.schedule_job_execution(job_ids, start_time='TIME_NOW') LOG.info("Waiting for iDRAC configuration to complete on {}".format( ip_service_tag)) LOG.info("Do not unplug {}".format(ip_service_tag)) # If the user set the password, then we need to change creds if password: new_drac_client = DRACClient(drac_ip, drac_user, password) # Try every 10 seconds over 2 minutes to connect with the new creds password_changed = False retries = 12 while not password_changed and retries > 0: try: LOG.debug("Attempting to access the iDRAC on {} with the " "new password".format(ip_service_tag)) new_drac_client.is_idrac_ready() password_changed = True except exceptions.WSManInvalidResponse as ex: if "unauthorized" in str(ex).lower(): LOG.debug( "Got an unauthorized exception on {}, so " "sleeping and trying again".format(ip_service_tag)) retries -= 1 if retries > 0: sleep(10) else: raise # If the new creds were successful then use them. If they were not # successful then assume the attempt to change the password failed # and stick with the original creds if password_changed: LOG.debug( "Successfully changed the password on {}. " "Switching to the new password".format(ip_service_tag)) drac_client = new_drac_client else: success = False LOG.warning("Failed to change the password on {}".format( ip_service_tag)) all_jobs_succeeded = wait_for_jobs_to_complete(job_ids, drac_client, ip_service_tag) if not all_jobs_succeeded: success = False if success and target_boot_mode == boot_mode_helper.DRAC_BOOT_MODE_BIOS: success = config_hard_disk_drive_boot_sequence(drac_client, ip_service_tag) # We always want to update the password for the node in the instack file # if the user requested a password change and the iDRAC config job was # successful regardless of if the other jobs succeeded or not. new_password = None if password: job_status = drac_client.get_job(idrac_job_id).status if JobHelper.job_succeeded(job_status): new_password = password if new_password is not None or \ "provisioning_mac" not in node or \ ("provisioning_mac" in node and node["provisioning_mac"] != provisioning_mac): # Synchronize to prevent thread collisions while saving the instack # file if instack_lock is not None: LOG.debug("Acquiring the lock") instack_lock.acquire() try: if instack_lock is not None: LOG.debug("Clearing and reloading instack") # Force a reload of the instack file CredentialHelper.clear_instack_cache() node = CredentialHelper.get_node_from_instack( ip_service_tag, node_definition) if new_password is not None: node["pm_password"] = new_password node["provisioning_mac"] = provisioning_mac LOG.debug("Saving instack") CredentialHelper.save_instack(node_definition) finally: if instack_lock is not None: LOG.debug("Releasing the lock") instack_lock.release() if success: LOG.info("Completed configuration of the iDRAC on {}".format( ip_service_tag)) else: raise RuntimeError("An error occurred while configuring the iDRAC " "on {}".format(drac_ip))