class CimcUtils(object): hostName = 'None' waitForPingFail = 'None' def __init__(self, cimc_handle, telnet_handle=None, host_handle=None, config=None, common_config=None): self.handle = cimc_handle self.telnet_handle = telnet_handle self.host_handle = host_handle self.bios_util_obj = BiosUtils(self, config, common_config) self.config = config self.ts_file_path = None # self.ts_file_path = 'tmpAutomation-testCase-bmc-2016-12-27_23-11-34.tar.gz' ''' Contructor for the class Parameters: Will be taken from global variables client : handle for connection prompt : Need to update to handle different cases ''' def get_scope_output(self, *scope_list, cmnd='show detail'): for scope in scope_list: self.handle.execute_cmd(scope) if cmnd is None: cmnd = 'show detail' else: cmnd = cmnd return self.handle.execute_cmd(cmnd, wait_time=8) 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 get_power_state(self): ''' Procedure to get current power state of host Parameter: handle : connection handle of cimc Return: Current power state: Success False : Failure ''' logger.info('Getting the current power state of host') try: self.handle.execute_cmd('top') self.handle.execute_cmd('scope chassis') out = self.handle.execute_cmd('show detail', wait_time=8) time.sleep(3) logger.info(out) return re.search(r'powerstate:\s+([^\r\n]+)', out).group(1) except: dump_error_in_lib() return False def set_host_power(self, power_state): ''' Procedure to power off/on the host Parameter: power_state: 'on' to power on the host 'off' to power off the host Return: True: Success False: Failure ''' try: cur_power_state = self.get_power_state() if cur_power_state == power_state: logger.info('Host is already in expected powered state: ' + cur_power_state) return True else: out = self.handle.execute_cmd_list('top', 'scope chassis', 'power ' + power_state, wait_time=6) if 'Do you want to continue' in out: self.handle.execute_cmd('y') else: logger.error('Failed to power off the host') return False cur_power_state = self.get_power_state() time.sleep(5) if cur_power_state == power_state: logger.info('Host is successfully set to: ' + cur_power_state) else: logger.error('Failed to power state of host to: ' + power_state) return False return True except: dump_error_in_lib() return False 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 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 bmc_factory_reset_and_connect(self): ''' Wrapper procedure to perform BMC factory reset and reconnects to BMC Parameter: None Return: True: Success False : Failure ''' try: logger.info( 'bmc_factory_reset_and_connect: BMC factory reset and re-connect procedure' ) if self.telnet_handle.bmc_serial_recover_testbed( self.config) is False: logger.error('Failed: to perform factory reset and reconnect') return False mgmt_detail_obj = self.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('Wait for BMC to come up') res = self.verify_host_up(bmc_ip, wait_time=180) if res is not True: logger.error( 'After BMC Factory reset, failed to ping BMC mgmnt IP') return False # reconnect the BMC after factory reset self.handle = LinuxUtils(bmc_ip, bmc_login, bmc_passwd) self.handle.connect() return True except: dump_error_in_lib() return False def ac_cycle_and_reconnect(self, config): logger.info('Performing AC cycle') apc_obj = config.apcdetails apc_ip = apc_obj.apc_ip port_list = apc_obj.port_list.split(',') model = apc_obj.model con = APCUtilClass(apc_ip, "apc1", "nbv12345") ret = con.ConnectToAPC() if ret != None: logger.info('Successfully connected to APC, model ' + model) else: logger.error('Failed to connect to APC, model ' + model) return False for port_num in port_list: logger.info('Switch off the power on port :' + port_num) # port_num = 10 operation = "off" val = con.SetPowerStatePort(port_num, operation) if val == None: logger.error('Failed to set power state of port number ' + str(port_num) + ' with : ' + operation) return False else: logger.info('Power state of port number ' + str(port_num) + ' set to : ' + operation) val = con.GetPowerStatePort(port_num) if val == None: logger.error('Failed to get power state of port number ' + str(port_num)) else: logger.info('Power state of port number ' + str(port_num) + ' is : ' + val) time.sleep(2) for port_num in port_list: logger.info('Switch On the power on port :' + port_num) operation = "on" val = con.SetPowerStatePort(port_num, operation) if val == None: logger.error('Failed to set power state of port number ' + str(port_num) + ' with : ' + operation) return False else: logger.info('Power state of port number ' + str(port_num) + ' set to : ' + operation) val = con.GetPowerStatePort(port_num) if val == None: logger.error('Failed to get power state of port number ' + str(port_num)) else: logger.info('Power state of port number ' + str(port_num) + ' is : ' + val) ''' reconnecting to mgmt handle ''' 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 res = self.verify_host_up(bmc_ip, wait_time=500) if res is not True: logger.error('After AC cycle, failed to ping BMC mgmt IP') return False else: logger.info('After AC cycle, able to ping BMC mgmt IP') self.handle = LinuxUtils(bmc_ip, bmc_login, bmc_passwd) self.handle.connect() return True def verify_host_up(self, hostname='default', wait_for_ping_fail=True, wait_time=500): ''' Procedure to verify if bmc/host is UP using ping Parameter: hostName : IP or hostname of the server to be checked 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 ''' pkt_count = 3 time_to_sleep = 10 ping_failed = False host_rebooted = False # sleep for wait_time timeout, default is max_wait_time = time.time() + wait_time if hostname == 'default': logger.info('Will use GlobalVariable for hostname : ' + str(hostname)) else: logger.info('Will verify for a provided host address : ' + str(hostname)) try: while True: # subpocess.check_output('/usr/bin/which ping') png_path = 'ping' logger.info('Ping tool path : ' + png_path) cmdstr = png_path + ' -c ' + str(pkt_count) + ' ' + hostname logger.info('Command: ' + cmdstr) exceptioncaught = False try: pngoutput = subprocess.check_output( cmdstr, shell=True, stderr=subprocess.STDOUT) except: # dump_error_in_lib() pngoutput = 'not all pings were successful' exceptioncaught = True logger.info('Output : ' + str(pngoutput)) obj = re.search( '[0-9]+ packets transmitted, [0-9]+ received, 0% packet loss', str(pngoutput)) logger.info('Object: ' + str(obj)) if obj != None and exceptioncaught != True: logger.info('Ping successful') if ping_failed == False and wait_for_ping_fail == True: logger.info('Ping failure didnt happen yet') else: logger.info('Host has rebooted and back up') host_rebooted = True break else: logger.info('Ping failed') ping_failed = True time.sleep(time_to_sleep) if time.time() > max_wait_time: logger.info('Maximum timeout reached') break else: logger.info('Will continue to wait') continue if host_rebooted == True: logger.info('Host successfully rebooted') return True else: logger.error('Host is not up') return False except: dump_error_in_lib() return False def HuuUpdate(self, huu_update_info, node='1'): ''' Method to update CIMC using HUU iso ''' mgmt_detail_obj = self.config.mgmtdetail bmc_ip = mgmt_detail_obj.bmc_mgmt_ip bmc_login = mgmt_detail_obj.bmc_login bmc_passwd = mgmt_detail_obj.bmc_password pl = mgmt_detail_obj.platform platformHash = { 'dn1': 'delnorte1', 'dn2': 'delnorte2', 'pl1': 'plumas1', 'pl2': 'plumas2', 'mad': 'madeira' } platform = platformHash[pl] logDir = easypy.runtime.directory logger.info('Log Dir is:' + logDir) release = huu_update_info[0] version = huu_update_info[1] node = '1' logger.info('**************************************') logger.info('HUU Update params are:') logger.info("platform {}, release {}, version {}".format( platform, release, version)) logger.info('**************************************') arg = "/data/home/releng/py/bin/python /auto/svbudata-home-bgl/releng/cluster_switch.main/rm_automation/tools/./upgradeWrapper1.py --testbed\ '{}' --cimcuserName '{}' --cimcPassword '{}' --updateComponent '{}' --platform '{}' --release '{}'\ --iso '{}' --logDir '{}' --serverNode {}".format( bmc_ip, bmc_login, bmc_passwd, 'all', platform, release, version, logDir, node) logger.info('upgrade command: ' + str(arg)) p = subprocess.Popen(arg, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = p.communicate() logger.info('Upgrade completed') logger.info('stdout: ' + str(out)) logger.info('stderr: ' + str(err)) if re.search("Firmware update successful for CIMC NOt found", str(out)): logger.error('CIMC update not found, HUU update failed') update = False elif re.search("Firmware update successful for CIMC", str(out)): logger.info( 'INFO : output_message : Firmware update successful for CIMC') update = True else: logger.error( 'ERROR: output_message : Firmware update successful for CIMC NOt found' ) update = False if update is False: logger.error('HUU Update Failed') return False else: logger.info('HUU upgrade success') # After HUU update connect back to CIMC self.handle = LinuxUtils(bmc_ip, bmc_login, bmc_passwd) self.handle.connect() return True def set_techsupport_param_value(self, param, new_value): ''' Procedure to set tech-support attribute values Parameter: handle: connection handle of cimc param: tech-support parameter value new_value: New desired value to set Return: True : Success False : Failure ''' logger.info('Setting tech-support parameter attribute values:') logger.info('Attribute: ' + str(param) + ' Value: ' + str(new_value)) self.handle.execute_cmd_list('top', 'scope cimc', 'scope tech-support') out = self.handle.execute_cmd('set ' + str(param) + ' ' + str(new_value), wait_time=8) match = re.search( 'invalid|exceeding|incomplete|Valid value|Maximum|cannot be used', out, re.I) if match is not None: logger.error('Failed to execute command; got error as: ' + str(match)) return False commit_out = self.handle.execute_cmd('commit') if re.search('ERROR', commit_out, re.IGNORECASE): logger.info('Unable to set parameter ' + str(param) + ' to ' + str(new_value) + ' : ' + str(commit_out)) self.handle.execute_cmd('discard') return False return True def get_techsupport_param_value(self, param): ''' Procedure to get tech-support attribute values Parameter: handle: connection handle of cimc param: tech-support parameter value Return: Value of the parameter that is asked False: Failure ''' try: logger.info('Fetching tech-support attribute param value: ' + str(param)) self.handle.execute_cmd_list('top', 'scope cimc', 'scope tech-support') out = self.handle.execute_cmd('show detail', wait_time=6) return re.search(param + ': ([^\r\n]+)', out).group(1) except: dump_error_in_lib() return False def check_techsupport_param_value(self, param, expected_value): ''' Procedure to validate tech-support attribute values Parameter: handle: connection handle of cimc param: tech-support parameter value expected_value: Value which we expect BMC to report back Return: True : Success False : Failure ''' try: if self.get_techsupport_param_value(param) is expected_value: return True else: 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 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 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 upload_techsupport_data(self, protocol='None'): ''' Wrapper procedure to start and wait for tech-support to complete Parameter: handle: connection handle of cimc Optional param: protocol: one of the protocol (currently supported 'tftp') Return: True : Success False : Failure ''' path_value = "remote-path" tftp_ip = "remote-ip" status_value = "remote-status" remore_protocol = "remote-protocol" time_stamp = strftime("%Y-%m-%d_%H-%M-%S") tftp_tmp_auto_file_name = 'tmpAutomation-testCase-bmc-' tftp_tmp_auto_file_name += str(time_stamp) tftp_tmp_auto_file_name += '.tar.gz' logger.info('Unique file name on TFTP server: ' + str(tftp_tmp_auto_file_name)) '''Set tech-support remote-path value''' if self.set_techsupport_param_value(path_value, tftp_tmp_auto_file_name) is False: logger.error('Failed to set remote-path value:' + str(tftp_tmp_auto_file_name)) return False '''set tech-support remote-ip parameter value''' '''Need to fetch this IP from config file''' remote_server_ip = '10.126.164.31' if self.set_techsupport_param_value(tftp_ip, remote_server_ip) is False: logger.error('Failed to set remote-ip value:' + str(remote_server_ip)) return False '''set remote protocol value''' if protocol is 'None': protocol = 'tftp' else: protocol = protocol '''Set tech-support remote-protocol parameter value''' if self.set_techsupport_param_value(remore_protocol, protocol) is False: logger.error('Failed to set remote-protocol value:' + str(protocol)) return False stage_value = self.get_techsupport_param_value(status_value) if stage_value == 'COLLECTING' or stage_value == 'UPLOADING': logger.error('BMC tech support progress is' + str(stage_value) + 'Can not continue') return False if self.start_and_wait_for_ts_to_finish() is False: return False self.ts_file_path = tftp_tmp_auto_file_name def get_cimc_sel_log_latest_event(self, log_scope='cimc'): ''' Procedure to get Latest Log entry before an event Return: returns latest event on : Success empty string if no CIMC logs : Failure Author : Jagadish Chanda <*****@*****.**> ''' try: logger.info("Inside get log proc") if log_scope == 'cimc': self.handle.execute_cmd_list('top', 'scope cimc', 'scope log') else: self.handle.execute_cmd_list('top', 'scope sel') log_before_event = self.handle.execute_cmd("show entries", wait_time=20) if '--More--' in log_before_event: log_output = self.handle.execute_cmd("R", wait_time=10) log_before_event += log_output while True: if '--More--' in log_output: log_output = self.handle.execute_cmd("R", wait_time=10) log_before_event += log_output log_output = '' else: break log_before_event = log_before_event.split("\n") if len(log_before_event) > 3: return log_before_event[3] else: logger.info( "There may be no CIMC Log entries before the event") return "" except: dump_error_in_lib() return False def clear_cimc_sel_logs(self, log_scope='cimc'): ''' Procedure to clear CIMC or SEL logs Parameter: log_scope: <cimc | sel> Return: True: On successfully clearing of logs False:On failed to clear logs ''' if log_scope == 'cimc': self.handle.execute_cmd_list('top', 'scope cimc', 'scope log') else: self.handle.execute_cmd_list('top', 'scope sel') out = self.handle.execute_cmd('clear') if 'Continue' in out: self.handle.execute_cmd('y') elif 'Clear the Cisco IMC log' in out: self.handle.execute_cmd('y') else: logger.warning('Failed to clear the logs') return False logger.info('Successfully cleared the logs') return True def check_cimc_sel_log_diff_event(self, log_before_event, log_scope='cimc', severity=["Critical"]): ''' Procedure to check cimc and sel log SEL : If the "log_scope" parameter should be sel and it will check for log diff and if any new log found it will return false CIMC : If log_scope parameter is cimc or by default it will get check cimc log. To check severity in cimc log pass the severity parameter as list with all desired severity. By default it will check for Critical event. Parameters: log_before_event: Latest Log entry before an event log_scope : cimc or sel (default cimc) severity : List severity to be checked.(default Critical events) Return: True if mention severity not found in the log: Success False : Failure Author : Jagadish Chanda <*****@*****.**> and Suren Kumar Moorthy<*****@*****.**> ''' try: if log_scope == 'cimc': self.handle.execute_cmd_list('top', 'scope cimc', 'scope log') else: self.handle.execute_cmd_list('top', 'scope sel') log_after_event = self.handle.execute_cmd('show entries', wait_time=20) if '--More--' in log_after_event: log_output = self.handle.execute_cmd("R") log_after_event += log_output while True: if '--More--' in log_output: log_output = self.handle.execute_cmd("R") log_after_event += log_output else: break log_after_event = log_after_event.split("\n") diff_list = [] if len(log_after_event) > 3: for i in range(3, len(log_after_event)): if log_after_event[i].strip( ) not in log_before_event.strip(): diff_list.append(log_after_event[i]) else: break else: logger.error("Failed to fetch the log difference") return False logger.info("######### Diff List ###################") logger.info(diff_list) logger.info("#########################################") if 'sel' in log_scope or 'cimc' in log_scope: if len(diff_list) > 0: logger.info(diff_list) logger.warning("Found Difference in sel/cimc log") log_found = 0 logger.info("######### Log Diff ##############") logger.info(diff_list) logger.info("#################################") if len(severity) > 1: sev_reg = "|".join(severity) elif len(severity) == 1: sev_reg = severity[0] else: sev_reg = 'Critical' rege = r'\d{2}\:\d{2}\:\d{2}\s+\w{3}\s+(?:' + sev_reg + ")" for log in diff_list: if re.search(rege, log): logger.error(log) log_found = 1 if log_found == 1: logger.error("Found called severity in log") return False else: return True except: dump_error_in_lib() return False def get_overall_health_status(self): ''' Procedure to get over all health status ''' return self.get_led_status() 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 validate_cdn_techsupport(self, config): con = ConfigParser() tftp_config = con.load_common_config().tftp_share remote_ip = tftp_config.tftp_server_ip remote_user = tftp_config.tftp_user remote_passwd = tftp_config.tftp_password tftp_root_dir = tftp_config.tftp_root_path tftp_handle = LinuxUtils(remote_ip, remote_user, remote_passwd) tftp_handle.connect() ts_path = tftp_root_dir + '/TechSupport/' tftp_handle.execute_cmd('mkdir -p ' + ts_path) tftp_handle.execute_cmd('chmod 777 ' + ts_path) tftp_handle.execute_cmd('tar -xzvf /TFTP_DIR/' + self.ts_file_path + ' ' + "-C" + ' ' + ts_path) platform_type = config.mgmtdetail.platform_series if platform_type == 'M5': cdn_ts = tftp_handle.execute_cmd('cat' + ' ' + ts_path + 'mnt/jffs2/BIOS/bt/BiosTech.log \ | grep "Patched eNIC Name"') else: cdn_ts = tftp_handle.execute_cmd('cat' + ' ' + ts_path + 'var/nuova/BIOS/BiosTech.txt \ | grep "Patched eNIC Name"') time.sleep(20) tftp_handle.disconnect() cdn_from_tsr = re.findall(r'=\s+([^\r\n\'\s]+)', cdn_ts) logger.info('CDN info from Tech-support data') logger.info(cdn_from_tsr) '''Getting CDN name from CIMC''' logger.info('Fetching CDN name from CIMC CLI') vic_list = config.inventory_detail vic_obj = VicLib(self, config) for vic in vic_list: slot_no = vic.slot_number out = vic_obj.cimc_cdn_mac_dict(slot_no) cnd_from_cimc = [] for cdn_name in out.values(): cnd_from_cimc.append(cdn_name) logger.info('CDN name from CIMC') logger.info(cnd_from_cimc) for val in cdn_from_tsr: if val not in cnd_from_cimc: logger.info( "From CIMC CDN name are not same as TSR CDN name") return False return True def remove_techsupport_file(self): ''' Procedure to remove the tech-support file Returns: True: on success False: on failure ''' try: logger.info('Deleting tech-support file: ' + self.ts_file_path) con = ConfigParser() tftp_config = con.load_common_config().tftp_share remote_ip = tftp_config.tftp_server_ip remote_user = tftp_config.tftp_user remote_passwd = tftp_config.tftp_password handle = LinuxUtils(remote_ip, remote_user, remote_passwd) handle.connect() handle.execute_cmd('rm -f ' + '/TFTP_DIR/' + self.ts_file_path) handle.disconnect() except: dump_error_in_lib() def get_sensor_data(self, type='voltage'): output = self.handle.execute_cmd_list('top', 'scope sensor', 'show ' + type) sensor_list = output.splitlines() sensor_out = [] for sensor in sensor_list: if sensor != sensor_list[0] and sensor != sensor_list[ 1] and sensor != sensor_list[2] and sensor != sensor_list[ 3] and sensor != sensor_list[4]: sensor_data = [] for val in sensor.split(' '): if val != '': sensor_data.append(val) sensor_out.append(sensor_data) logger.info('sensor out is') logger.info(sensor_out) return sensor_out def verfiy_sol_screen(self, config): sol_enabled = self.bios_util_obj.get_common_token_value( "enabled", "sol") logger.info("Sol enabled value is" + sol_enabled) if 'no' in sol_enabled: status = self.bios_util_obj.set_common_token_value("enabled", "yes", "sol", commit_wait=120) if status is False: logger.error("Failed to set sol enabled to yes") return False sol_out = self.handle.execute_cmd_list('top', 'scope sol', 'connect host', "\n") logger.info(sol_out) host_info_obj = config.host_info[0].host_detail prompt = host_info_obj.os_host_name logger.info("Prompt " + prompt) out = self.handle.execute_cmd_list(chr(24)) logger.info(out) if prompt in sol_out: logger.info("Successfully verified sol") return True elif re.search(r'(login)|(password)\:', sol_out).group(0): logger.info( "Successfully verified sol matched login or password prompt") return True else: logger.error("Failed to verify sol") return False def get_platform_name(self, plat): plat_dict = {"dn1": "delnorte1"} return plat_dict[plat] 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()
class ExpImpUtils(): def __init__(self, cimc_utils_obj, config, common_config): self.cimc_utils_obj = cimc_utils_obj self.handle = cimc_utils_obj.handle self.config = config self.common_config = common_config self.tftp_ip = self.common_config.tftp_share.tftp_server_ip self.tftp_user = self.common_config.tftp_share.tftp_user self.tftp_password = self.common_config.tftp_share.tftp_password self.tftp_handle = LinuxUtils(self.tftp_ip, self.tftp_user, self.tftp_password) self.tftp_root_dir = self.common_config.tftp_share.tftp_root_path self.export_path = None def export_vic_config(self, slot_no, protocol='tftp', server=None, path=None, user=None, password=None): ''' Procedure to export VIC configuration Parameter: slot_no: slot number on adapter card is present protocol: Protocol to use { tftp | ftp | sftp | scp | http } server: Remote server IP address path: Image file path on the remote server user: remote server user name password: remote server user password Return: True : Success False : Failure ''' try: if server == None: remote_dir = '/vic_export/' remote_path = self.tftp_root_dir + remote_dir self.tftp_handle.connect() logger.info('Successfully connected to remote tftp server') self.tftp_handle.execute_cmd_list('mkdir -p ' + remote_path) self.tftp_handle.execute_cmd_list('chmod 777 ' + remote_path) self.tftp_handle.disconnect() self.handle.execute_cmd_list('top', 'scope chassis', 'scope adapter ' + slot_no) vic_xml_file = "vic_config" + "_" + "slot_no_" + slot_no if protocol is 'tftp' or protocol is 'http': out = self.handle.execute_cmd('export-vnic' + ' ' + protocol + ' ' + self.tftp_ip + ' ' + remote_dir + vic_xml_file, wait_time=6) if 'Export succeeded' in out: logger.info( 'VIC export operation completed successfully: ' + remote_path + vic_xml_file) self.export_path = remote_path + vic_xml_file else: logger.exception('Failed to export VIC config data') return False elif protocol is 'sftp' or protocol is 'scp': out = self.handle.execute_cmd('export-vnic' + ' ' + protocol + ' ' + self.tftp_ip + ' ' + remote_path + vic_xml_file, wait_time=6) if 'Do you wish to continue' in out: self.handle.execute_cmd('y') time.sleep(1) self.handle.execute_cmd(user) time.sleep(1) out = self.handle.execute_cmd(password, wait_time=6) if 'Export succeeded' in out: logger.info( 'VIC export operation completed successfully') self.export_path = remote_path + vic_xml_file else: logger.exception('Failed to export VIC config data') return False elif protocol is 'ftp': self.handle.execute_cmd('export-vnic' + ' ' + protocol + ' ' + self.tftp_ip + ' ' + remote_dir + vic_xml_file, wait_time=6) self.handle.execute_cmd(user) time.sleep(1) out = self.handle.execute_cmd(password, wait_time=6) if 'Export succeeded' in out: logger.info('VIC export operation completed successfully') self.export_path = remote_path + vic_xml_file else: logger.exception('Failed to export VIC config data') return False else: logger.error('Invalid protocol selected') return False return True except: dump_error_in_lib() return False def validate_vic_config(self, slot_no): logger.info("Verifying the VIC configuration exported for slot no " + slot_no) self.tftp_handle.connect() out = self.tftp_handle.execute_cmd('cat ' + self.export_path + ' | ' + 'grep -F "<CDN>"') self.tftp_handle.disconnect() cdn_name_from_export = re.findall(r'<CDN>(\w+)<\/CDN>', out) logger.info('exported CDN_names are') logger.info(cdn_name_from_export) logger.info('Fetching CDN name from CIMC CLI') vic_obj = VicLib(self.cimc_utils_obj, self.config) out = vic_obj.cimc_cdn_mac_dict(slot_no) cnd_name_from_cimc = [] for cdn_name in out.values(): cnd_name_from_cimc.append(cdn_name) logger.info('CDN Name from CIMC list:' + str(cnd_name_from_cimc)) ''' if len(cnd_name_from_cimc) != len(cdn_name_from_export): logger.error('Both lists have different size lengths') return False ''' for val in cdn_name_from_export: if val not in cnd_name_from_cimc: logger.info("From CIMC CDN name are not same as TSR CDN name") return False return True 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()