def validate_host_console_output(self, exp_string, wait_time=500): '''Procedure to verify the expected string on host console output during boot''' logger.info('Looking for the console output {}'.format(exp_string)) try: out = self.host_conn_handle.read_until(exp_string, wait_time) logger.info('Host console output:') logger.info(out) found_string = False for line in out.splitlines(): logger.info(line) if exp_string in line: logger.info('Found expected string') found_string = True break if exp_string in out: found_string = True if found_string is True: logger.info( 'Successfully validated the expected string {} found \ in console output'.format(exp_string)) return True else: logger.error( 'Failed to validate that expected string {} found \ in console output'.format(exp_string)) return False except: dump_error_in_lib() logger.error( 'Failed to validate console output with expected string {}'. format(exp_string)) return False
def copy_file_to_share(self, file_name, path_to_copy): ''' copies the file to share path returns - True if successfull returns - False if unscessfull ''' try: if not os.path.exists(path_to_copy): logger.info( path_to_copy + " Directory doesnt exists .Hence creating directory") os.makedirs(path_to_copy) os.chmod(path_to_copy, stat.S_IRWXO) copy_command = "cp -rf " + file_name + " " + path_to_copy copy_output = subprocess.check_output(copy_command, shell=True, stderr=subprocess.STDOUT) logger.info(str(copy_output)) file_path = path_to_copy + file_name if os.path.exists(file_path): logger.info("Successfull copied the file to the path :" + file_path) return True else: logger.error("Error in copying the file: " + file_name + "to directory:" + path_to_copy) return False except: dump_error_in_lib() logger.error("Expection obtained in Copying the file" + file_name + "to directory:" + path_to_copy) return False
def delete_vnic(self, slot_no, dev_name): ''' Procedure to delete vnic interface Parameter: slot_no: slot number on interface device is created dev_name: name of device e.g: eth2 Return: True : Success False : Failure ''' try: logger.info('Deleting the vnic interface') out = self.handle.execute_cmd_list('top', 'scope chassis', 'scope adapter ' + str(slot_no), wait_time=6) if 'Error: Managed object does not exist' in out: logger.error( 'vnic interface {} does not exists'.format(dev_name)) return False self.handle.execute_cmd('delete host-eth-if ' + dev_name, wait_time=12) out = self.handle.execute_cmd('commit', wait_time=10) if 'Deleted host-eth-if' in out: logger.info('Successfully deleted vnic interface ' + dev_name) return True else: logger.error('Failed to delete vnic interface ' + dev_name) return False except: dump_error_in_lib() return False
def start_tech_support(self): ''' Procedure to start tech-support Parameter: handle: connection handle of cimc Return: True : Success False : Failure ''' try: self.handle.execute_cmd_list('top', 'scope cimc', 'scope tech-support') out = self.handle.execute_cmd('start', wait_time=8) logger.info(out) if "Tech Support upload started" in out: logger.info( 'Tech Support Upload start command was issued successfully' ) return True match = re.search( 'invalid command detected|Already an upload is in \ progress|Hostname/IP Address|is not reachable', out, re.I) if match is not None: logger.error('Can not issue tech-support start command') return False except: dump_error_in_lib() return False
def get_cpu_info_host(self, host_handle, token=None): ''' Collect proccesor information like threads and core from host Parameter : host handle token : passing this token will send only the specific tokens(thread,cores) Return : Returns dictionary with host details if token parameter is none else it will return the token value : Success False : Failure ''' try: cpu_info_host = {} out = host_handle.execute_cmd("cat /proc/cpuinfo", buffer_size=100000, wait_time=20) cpu_info_host['thread'] = len(re.findall(r'processor\s*\:\s*(\d+)', out)) cpu_info_host['cores'] = re.search(r'cpu\s*cores\s*\:\s*(\d+)', out).group(1) if token is None: return cpu_info_host else: return cpu_info_host[token] except: dump_error_in_lib() return False
def start_and_wait_for_ts_to_finish(self): ''' Wrapper procedure to start and wait for tech-support to complete Parameter: handle: connection handle of cimc Return: True : Success False : Failure ''' try: if self.start_tech_support() is False: logger.error('Tech-support start command failed') return False if self.has_techsupport_started() is False: logger.error( 'The tech-support status not started after start command was issued' ) return False if self.wait_for_techsupport_to_finish() is False: logger.error( "Tech support upload did not finish in max timeout seconds" ) return False return True except: dump_error_in_lib() return False
def get_led_status(self, led="LED_HLTH_STATUS"): ''' Procedure to get led state of server Parameter: led: Default - LED_HLTH_STATUS or Pass the appropriate led name to get the status Return: Led status: Success False : Failure Author: Suren kumar Moorthy ''' logger.info('Getting the LED status') try: out = self.handle.execute_cmd_list( ['top', 'scope chassis', 'show led detail'], wait_time=10) logger.info(out) regex = r'name\:\s*' + led + \ r'\s*state\s*\:\s*\w+\s*color\:\s*(\w+)' return re.search(regex, out).group(1) except: dump_error_in_lib() return False
def load_cpu_obj(self): ''' To Load CPU object from config Return: Object populated with processor details : SUCCESS False : FAILURE Authhor : Suren Kumar Moorthy ''' try: logger.info("Loading CPU object from Config") self.handle.execute_cmd_list("top", "scope chassis") out = self.handle.execute_cmd("show cpu detail") regex = r'(?:(?:Xeon\(R\)\s*CPU\s+([a-zA-Z0-9\s\-]+)(?:\s+)?\@)|(?:Xeon\(R\)\s*([a-zA-Z0-9\s\-]+)\s+CPU))' model_reg_out = re.search(regex, out) model = str(model_reg_out.group(2)) if model_reg_out.group(1) is None else str(model_reg_out.group(1)) rep = re.compile(r'\s+$') model = rep.sub('', model) rep = re.compile(r'\s+') model = rep.sub('-', model) logger.info('Model selected: ' +model) con = ConfigParser() proccessor_config = con.load_processor_config(model).proceesor_details return proccessor_config except: dump_error_in_lib() return False
def file_compare(self, file_path_1, file_path_2): ''' Compares two files and returns True if there is no difference ''' try: file1 = open(file_path_1, "r") file2 = open(file_path_2, 'r') file_diff = difflib.context_diff(file1.readlines(), file2.readlines()) delta = ''.join(file_diff) if not delta: logger.info( " There is not differece between the STD and Lstest data" + str(delta)) return True else: logger.error( " There is difference between STD and latest data" + str(delta)) return False except: dump_error_in_lib() logger.info( " Exception obtained while comparing the STD and laetst config files" ) return False
def has_techsupport_started(self): ''' Procedure to check whether tech-support has started collecting data Parameter: handle: connection handle of cimc Return: True : Success False : Failure ''' try: self.handle.execute_cmd_list('top', 'scope cimc', 'scope tech-support') out = self.handle.execute_cmd('show detail', wait_time=6) logger.info(out) out = re.search('remote-status: ([^\r\n]+)', out).group(1) if out == "COLLECTING": logger.info('The Update is in progress') return True elif out == "COMPLETED": logger.error( 'The tech-support status not started after start command was issued' ) return False except: dump_error_in_lib() return False
def wait_for_techsupport_to_finish(self, wait_time=1200): ''' Procedure to wait until tech-support is completed Parameter: handle: connection handle of cimc Optional Param: wait_time: Maximum time to wait for tech-support to complete Return: True : Success False : Failure ''' try: max_wait_time = time.time() + wait_time while time.time() < max_wait_time: out = self.get_techsupport_param_value('progress') if out == "100": logger.info('Successfully uploaded tech-support data') return True elif 'Remote_Upload_Error' in out: logger.error('Upload error happened, will exit') return False time.sleep(10) logger.info('Will continue to wait') logger.info('Exceeded max wait time ' + str(max_wait_time) + ' seconds') return False except: dump_error_in_lib() return False
def reboot_bmc_and_connect(self, config): ''' Procedure to reboot BMC and reconnects the BMC Parameter: None Return: True: Success False : Failure ''' try: logger.info('Rebooting CIMC') self.handle.execute_cmd_list('top', 'scope cimc', 'reboot', 'y') mgmt_detail_obj = config.mgmtdetail bmc_ip = mgmt_detail_obj.bmc_mgmt_ip bmc_login = mgmt_detail_obj.bmc_login bmc_passwd = mgmt_detail_obj.bmc_password logger.info('Successfully rebooted BMC, Wait for BMC to come up') res = self.verify_host_up(bmc_ip, wait_time=500) if res is not True: logger.error('After BMC reboot, failed to ping BMC mgmt IP') return False else: logger.info( 'Successfully rebooted BMC, connecting back to BMC') self.handle = LinuxUtils(bmc_ip, bmc_login, bmc_passwd) self.handle.connect() return True except: dump_error_in_lib() return False
def get_common_token_value(self, token, scope, sub_scope=None): ''' Procedure to get bios values by passing its token name Parameter: param: Default - None or Pass the appropriate name of the token to get the value (Pass sub scope name to get token values inside sub scopes like advance,server-management,main,bios-profile,boot-device) Return: Token value: Success False : Failure Author: Suren kumar Moorthy ''' logger.info('Getting bios token value') try: if sub_scope is None: out = self.handle.execute_cmd_list('top', 'scope ' + scope, 'show detail', wait_time=8) else: out = self.handle.execute_cmd_list('top', 'scope ' + scope, 'scope ' + sub_scope, 'show detail', wait_time=8) logger.info(out) regex = token + r'\s*\:\s+([^\r\n]+)' return re.search(regex, out).group(1) except: dump_error_in_lib() return False
def is_msr_bitSet(self, operand, mask_string, flag, bit_position): ''' Bit Manipulator Procedure to masks the bits of the msr value per core to get the value of the required bit Parameter: param: operant - Corevalue from EFI mask_string - Mask value flag - "and" or "or" bit_position - bit position to check Return: Bit value: Success False : Failure Author: Suren kumar Moorthy ''' try: per_core_value = int("0x" + operand, 16) mask_value = int("0x" + mask_string, 16) if flag == "and": res = per_core_value & mask_value if res > 0: bit_array = list("{0:b}".format(res)) bit_array.reverse() return bit_array[int(bit_position)] else: return res elif flag == "or": return per_core_value | mask_value else: return False except: dump_error_in_lib() return False
def connect(self): ''' Connects to the host with given credentials and saves the handle in the current object ''' try: remote_conn_pre = paramiko.SSHClient() # Automatically add untrusted hosts (make sure okay for security # policy in your environment) remote_conn_pre.set_missing_host_key_policy( paramiko.AutoAddPolicy()) # initiate SSH connection remote_conn_pre.connect(self.ip, username=self.username, password=self.password, look_for_keys=False, allow_agent=False) self.handle = remote_conn_pre.invoke_shell() self.handle.keepthis = remote_conn_pre logger.info("Successfully connected to the host with IP:" + self.ip + " username:"******" password:"******"set cli output yaml") self.handle.settimeout(10) except: dump_error_in_lib() return False
def change_default_password(self): logger.info("Changing the default password") original_password = '******' mgmnt_password = '******' try: self.mgmnt_conn_handle.read_until(b'Enter current password: '******'Entering current password:'******'ascii') + b'\n') self.mgmnt_conn_handle.read_until(b'Enter new password: '******'Entering new password:'******'ascii') + b'\n') self.mgmnt_conn_handle.read_until(b'Re-enter new password: '******'Re-Entering new password:'******'ascii') + b'\n') self.mgmnt_conn_handle.read_until(b'Updating password...', 5) self.mgmnt_conn_handle.read_until( b'Password updated successfully.', 5) logger.info('Password Successfully Changed') return True except: dump_error_in_lib() return False
def get_cpu_info(self): ''' Get Cpu info from CimcUtils Procedure loads the cpu info in processor object Return: Object populated with processor details : SUCCESS False : FAILURE Authhor : Suren Kumar Moorthy ''' try: self.handle.execute_cmd_list("top", "scope chassis") out = self.handle.execute_cmd("show cpu detail") token_list = ["name", "manufacturer", "family", "thread-count", 'core-count', "version", "current-speed", "signature", 'cpu-status'] main_param_list = [] out_list = out.split("---") for out_bloc in out_list[1:]: param_list = [] for token in token_list: regex = re.escape(token) + r'\s*\:\s+([^\r\n]+)' value = re.search(regex, out_bloc).group(1) param_list.append(value) if token == 'version': model_regex = r'(?:(?:Xeon\(R\)\s*CPU\s+([a-zA-Z0-9\s\-]+)\s+\@)|(?:Xeon\(R\)\s*([a-zA-Z0-9\s\-]+)\s+CPU))' model_reg_out = re.search(model_regex, value) model = str(model_reg_out.group(2)) if model_reg_out.group(1) is None else str(model_reg_out.group(1)) print('=========*****========****====') print(model) print('=========*****========****====') rep1 = re.compile(r'\s$') model = rep1.sub('', model) rep2 = re.compile(r'\s+') model = rep2.sub('-', model) param_list.append(model) main_param_list.append(param_list) self.handle.execute_cmd_list("top", "scope chassis") pid_out = self.handle.execute_cmd("show cpu-pid detail", wait_time=20) token_list_pid = ["Description", "PID"] pid_out_list = pid_out.split("---") i = 0 for pid_out_bloc in pid_out_list[1:]: for token_pid in token_list_pid: regex_pid = re.escape(token_pid) + r'\s*\:\s+([^\r\n]+)' value_pid = re.search(regex_pid, pid_out_bloc).group(1) main_param_list[i].append(value_pid) self.cpu_details.append(Processor(main_param_list[i][0], main_param_list[i][1], main_param_list[i][2], main_param_list[i][3], main_param_list[i][4], main_param_list[i][5], main_param_list[i][6], main_param_list[i][7], main_param_list[i][8], main_param_list[i][9], main_param_list[i][10], main_param_list[i][11])) i += 1 return self.cpu_details except: dump_error_in_lib() return False
def connect_to_mgmnt(self): try: logger.info('Console IP {} and Port {}'.format( self.ip, self.mgmnt_port)) telnet_handle = telnetlib.Telnet(self.ip.encode('ascii'), self.mgmnt_port) telnet_handle.set_debuglevel(10) self.mgmnt_conn_handle = telnet_handle self.mgmnt_conn_handle.write(b'\n') self.mgmnt_conn_handle.write(b'\n') time.sleep(3) cur_mode = self.get_cimc_serial_mode() if cur_mode == None: # send cntr+C signal to return to sldp or help prompt self.mgmnt_conn_handle.write(b'\x03') self.connect_debug_shell_serial(connectShell='None', sldp_enabled='yes') elif cur_mode == 'responseKeyMode': self.connect_debug_shell_serial(connectShell='None') elif cur_mode == 'sldpMode' or cur_mode == 'helpMode': self.connect_debug_shell_serial(connectShell='None', sldp_enabled='yes') return self.mgmnt_conn_handle except: logger.warning('Entering exception block in: connect_to_mgmnt') dump_error_in_lib() tem_handle = self.connect_to_terminal_srvr() # Have to handle the server_Type here if self.server_type == None or 'cisco' in self.server_type: i = 0 while i < 4: tem_handle.write(b'clear line ' + str(self.mgmnt_port)[2:].encode('ascii') + b'\n') tem_handle.read_until(b'[confirm]', 5).decode('ascii') tem_handle.write(b'\n') i += 1 time.sleep(3) logger.info('in while with loop count' + str(i)) try: telnet_handle = telnetlib.Telnet(self.ip.encode('ascii'), self.mgmnt_port) telnet_handle.set_debuglevel(10) self.mgmnt_conn_handle = telnet_handle self.mgmnt_conn_handle.write(b'\n') self.mgmnt_conn_handle.write(b'\n') time.sleep(3) if self.get_cimc_serial_mode() == 'responseKeyMode': self.connect_debug_shell_serial(connectShell='None', sldp_enabled='yes') return self.mgmnt_conn_handle except: dump_error_in_lib() logger.error('Connection issue check terminal ') return None
def execute_cmd(self, cmd): result = None try: result = self.connection.run_cmd(cmd) logger.info("output of the execute command in windows is" + result.__str__()) except: dump_error_in_lib() return result.std_out
def verify_keys_values(self, smbios_dict, config_file_dict, verify_list=None): try: smbios_dict_efi = smbios_dict smbios_dict_file = config_file_dict result = 0 for key in smbios_dict_file: logger.info("key..." + key) if verify_list is not None: if key in verify_list: logger.info("key= " + key + "found in the dynamic list") logger.info( "key=....." + key + "..value...=" + smbios_dict_file[key]) EFI_shell_value = smbios_dict_efi[ key].replace(" ", "").strip().lower() Config_file_value = smbios_dict_file[ key].replace(" ", "").strip().lower() out = re.match( Config_file_value, EFI_shell_value, re.IGNORECASE) if out is not None: logger.info( "Server obtained value for" + key + "...=" + smbios_dict_efi[key]) logger.info( "SMBIOS CONFIG FILE obtained value for" + key + "...=" + smbios_dict_file[key]) logger.info("Values matched") else: logger.error( "server obtained value for " + key + "...=" + smbios_dict_efi[key]) logger.error( " CONFIG FILE obtained value for " + key + "...=" + smbios_dict_file[key]) logger.error( "server obtained value and CONFIG File values mismatch") result = 1 else: # logger.info("key=....."+key+"..value...="+smbios_dict_file[key]) EFI_shell_value = smbios_dict_efi[key].replace( " ", "").strip().lower().replace(')', '').replace('(', '') Config_file_value = smbios_dict_file[key].replace( " ", "").strip().lower().replace(')', '').replace('(', '') out = re.match( Config_file_value, EFI_shell_value, re.IGNORECASE) if out is not None: logger.info( "Server obtained value for" + key + "...=" + EFI_shell_value) logger.info( "SMBIOS CONFIG FILE obtained value for" + key + "...=" + Config_file_value) logger.info("Values matched") else: logger.error( "server obtained value for " + key + "...=" + EFI_shell_value) logger.error( " CONFIG FILE obtained value for " + key + "...=" + Config_file_value) logger.error( "server obtained value and CONFIG File values mismatch") result = 1 return result except: dump_error_in_lib() return 1
def __init__(self, ip_address=None, user_name=None, password=None): self.ip_addr = ip_address self.user = user_name self.password = password try: self.connection = winrm.Session(self.ip_addr, auth=(self.user, self.password)) except: dump_error_in_lib()
def power_cycle_host(self, wait_time=60): ''' Procedure to power cycle the host Parameter: handle : connection handle of cimc waitForPingFail : If true, will wait for ping to fail and then back up If False, will return True in case host is responding wait_time : Max time attempted to check host's availability Return: True : Success False : Failure ''' power_off = 0 power_on = 0 try: power_state = self.get_power_state() if power_state == 'off': logger.info('Host is already powered off, powering on') power_off = 1 self.set_host_power('on') else: self.handle.execute_cmd_list('top', 'scope chassis', 'power cycle', wait_time=6) time.sleep(1) self.handle.execute_cmd('y') # have to add validation max_wait_time = time.time() + wait_time # wait for 60 sec while True: power_state = self.get_power_state() if power_state == 'off': logger.info('Host is powered off') power_off = 1 elif power_state == 'on': logger.info('Host is powered on') power_on = 1 if power_on == 1 and power_off == 1: break if time.time() > max_wait_time: logger.info('Maximum timeout reached') break else: logger.info('Will continue to wait') time.sleep(2) if power_off == 1 and power_on == 1: logger.info('Successfully power cycled the host') return True else: logger.info('Failed to power cycled the host') return False except: dump_error_in_lib() return False
def remove_vic_config(self): ''' Procedure to remove the VIC exported file Returns: True: on success False: on failure ''' try: logger.info('Deleting vic export config file: ' + self.export_path) self.tftp_handle.connect() self.tftp_handle.execute_cmd('rm -f ' + self.export_path) self.tftp_handle.disconnect() except: dump_error_in_lib()
def verify_msr_mode(self, mode, mask_id, bit, verify_bit, out=None): ''' To verify the mode Parameter : mode : MSR value mask_id : Mask id for the msr value bit : which bit to check(Ex : 18 th bit) verify_bit : Bit to verify (1 or 0) Return: True or false Author : Suren Kumar Moorthy ''' try: if out is None: host_serial_handle = self.bios_util_obj.cimc_obj.telnet_handle efi_out = self.boot_order_obj.boot_to_efi_shell() if efi_out is False: return False msr_input = 'MSR ' + self.msr[mode] out = host_serial_handle.execute_cmd_serial_host(msr_input, wait_time=40) logger.info(out) host_serial_handle.disconnect() time.sleep(60) match = re.search(r'\d+\s+\d+\s+\d+\s+([0-9A-Z]{8})\s+([0-9A-Z]{8})', out) if match is None: logger.error('Unknown MSR Output') return False core = 1 fail_flag = 0 pattern = re.compile(r'\d+\s+\d+\s+\d+\s+([0-9A-Z]{8})\s+([0-9A-Z]{8})') for (data1, msr_bit) in re.findall(pattern, out): msr_val = data1 + msr_bit logger.info("Verify BIT value" + msr_val) bit_val = self.is_msr_bitSet(msr_val, mask_id, "and", bit) logger.info("Bit Value got is %s" % bit_val) logger.info("verify Value got is %s" % verify_bit) if int(bit_val) == int(verify_bit): logger.info("Bit value for core " + str(core) + " passed") else: fail_flag = 1 core += 1 if fail_flag == 1: return False else: return out except: dump_error_in_lib() return False
def restore_tokens_to_defaults(self, restore_type): ''' Procedure to set bios tokens to default values Parameter: None Return: True : Success False : Failure Author: jchanda ''' try: logger.info('Performing bios restore operation: %s' % (restore_type)) self.handle.execute_cmd_list('top', 'scope bios') if restore_type == 'bios-setup-default': out = self.handle.execute_cmd('bios-setup-default') elif restore_type == 'clear-cmos': # Power off the system to run clear-cmos command self.cimc_obj.set_host_power('off') out = self.handle.execute_cmd_list('top', 'scope bios', 'clear-cmos') elif restore_type == 'restore-mfg-defaults': # Power off the system to run restore-mfg-defaults command self.cimc_obj.set_host_power('off') out = self.handle.execute_cmd_list('top', 'scope bios', 'restore-mfg-defaults') else: logger.warning('Invalid bios token restore option: %s' % (restore_type)) return False if 'Continue' in out: out = self.handle.execute_cmd('y') if re.search('Error', out): logger.error( 'Failed to perform %s operation. Got Error Msg: %s ' % (restore_type, out)) return False logger.info("Waiting for host to come up") res = self.cimc_obj.verify_host_up(hostname=self.host_ip, wait_for_ping_fail=False) if res is False: logger.warning('Failed to ping the host') except: dump_error_in_lib() return False logger.info('Successfully performed operation %s' % (restore_type)) return True
def get_host_eth_int_details(self, adapter_slot): ''' Get Host Ethernet interface Details Procedure to load the Ethernet intf detail in HostEthInt object Return: Object populated with host eth interface details : SUCCESS False : FAILURE Author : jchanda ''' try: self.handle.execute_cmd_list('top', 'scope chassis', 'scope adapter ' + adapter_slot) output = self.handle.execute_cmd('show host-eth-if detail', wait_time=15) attr_list = [ 'name', 'mtu', 'uplink', 'mac-addr', 'cos', 'trust-host-cos', 'pci-link', 'order', 'vlan', 'rate-limit', 'boot', 'iscsi-boot', 'usnic-count', 'channel-number', 'port-profile', 'uplink-failover', 'uplink-failback-timeout', 'arfs', 'vmq', 'nvgre', 'vxlan', 'CDN', 'rdma_qp', 'rdma_mr', 'rdma_resgrp' ] out_list = output.split("---") for out_block in out_list[1:]: intf_tmp_list = [] for attr in attr_list: value = re.search(attr + ': ([^\r\n.$]+)', out_block) if value != None: value = value.group(1) intf_tmp_list.append(value) self.eth_int_details.append( HostEthInt( intf_tmp_list[0], intf_tmp_list[1], intf_tmp_list[2], intf_tmp_list[3], intf_tmp_list[4], intf_tmp_list[5], intf_tmp_list[6], intf_tmp_list[7], intf_tmp_list[8], intf_tmp_list[9], intf_tmp_list[10], intf_tmp_list[11], intf_tmp_list[12], intf_tmp_list[13], intf_tmp_list[14], intf_tmp_list[15], intf_tmp_list[16], intf_tmp_list[17], intf_tmp_list[18], intf_tmp_list[19], intf_tmp_list[20], intf_tmp_list[21], intf_tmp_list[22], intf_tmp_list[23], intf_tmp_list[24])) return self.eth_int_details except: dump_error_in_lib() return False
def create_dict_from_output(self, EFI_output): try: lines = EFI_output.split("\n") generate_dict_efi = {} smbios_dict_file = {} logger.info("..... Server Obtained EFI SMBIOS values......") for line in lines: if line.find(':') != -1: key1 = line.split(':')[0].replace(' ', '').strip().lower() value1 = line.split(':')[1].replace(' ', '').strip().lower() logger.info(key1 + "....." + value1) generate_dict_efi[key1] = value1 return generate_dict_efi except: dump_error_in_lib() return False
def get_cimc_serial_mode(self): """ Procedure to return current cimc serial mode Return Value: On Success it will returns either of one 'linuxMode' 'cliMode' 'debugMode' None in case of failure """ logger.info('Calling get_cimc_serial_mode method') try: time.sleep(1) out = self.execute_cmd_serial('\n') time.sleep(2) linux_prompt = ':~]$' cli_prompt1 = 'bmc#' cli_prompt2 = ' #' cli_prompt3 = '# ' cli_prompt4 = '--More--' help_prompt = '[ help ]#' response_key_prompt = 'ResponseKey#>' mode = None change_passwd_prompt = 'Enter current password: '******'[ sldp ]#' if linux_prompt in out: mode = 'linuxMode' elif help_prompt in out: mode = 'helpMode' elif sldp_prompt in out: mode = 'sldpMode' elif response_key_prompt in out: mode = 'responseKeyMode' elif change_passwd_prompt in out: mode = 'changePasswdMode' elif cli_prompt1 in out or cli_prompt2 in out or \ cli_prompt3 in out or cli_prompt4 in out: mode = 'cliMode' else: mode = None logger.info('CIMC serial in: ' + str(mode)) return mode except: logger.warning('Exception in def get_cimc_serial_mode') dump_error_in_lib()
def get_release_note_content(self, config): try: mgmt_detail_obj = config.mgmtdetail plat = mgmt_detail_obj.platform platform = self.get_platform_name(plat) build = os.environ["BUILD"] huu_image = os.environ["HUU_IMAGE"] if not build: logger.error("Build is not set in environment variable") return False if not huu_image: logger.error("HUU IMAGE is not set in environment variable") return False huu_iso_file = "/var/www/html/HUU_Sanity/systemupgrade/isos/" + \ platform + "/" + build + "/" + huu_image logger.info("HUU FILe: " + huu_iso_file) host = LinuxUtils('10.127.45.20', 'root', 'HuuWelcome123') host.connect() if "No such file or directory" in host.execute_cmd("ls " + huu_iso_file): logger.error("HUU file not found in filer") return False # Mouting ISO logger.info("Mouting ISO" + huu_iso_file) mount_folder = "/mnt/" + \ re.search(r'(.*?)\.iso', huu_image).group(1) logger.info("Mount Foleder" + mount_folder) host.execute_cmd("mkdir " + mount_folder) # Check mount folder if "No such file or directory" in host.execute_cmd("ls " + mount_folder): logger.error("mount folder is not found in filer") return False host.execute_cmd("mount -o loop " + huu_iso_file + " " + mount_folder) if "No such file or directory" in host.execute_cmd("ls " + mount_folder + "/TOC*.xml"): logger.error("TOC file not found") return False toc_out = host.execute_cmd("cat " + mount_folder + "/TOC*.xml") host.disconnect() return toc_out except: dump_error_in_lib()
def reboot_bmc(self, handle): ''' Procedure to get current power state of host Parameter: handle : connection handle of cimc Return: True: Success False : Failure ''' logger.info('Rebooting CIMC') try: logger.info(handle.execute_cmd('scope cimc')) logger.info(handle.execute_cmd('reboot')) logger.info(handle.execute_cmd('y')) return True except: dump_error_in_lib() return False