def check_cores(self): """Verify if any core on the device. Returns: Core files name Example: >>> check_cores() """ cores = [] # Execute command to check for cores header = [ "VDC", "Module", "Instance", "Process-name", "PID", "Date\(Year-Month-Day Time\)" ] if self.device.alias == 'uut': # In case of restarting process on a the main VDC output = oper_fill_tabular(device=self.device, show_command='show cores vdc-all', header_fields=header, index=[5]) else: # In case of restarting process on a sub-VDC self.device.disconnect() output = oper_fill_tabular(device=self.device, show_command='show cores', header_fields=header, index=[5]) if not output.entries: log.info('No core found') return [] # Parse through output to collect core information (if any) for k in sorted(output.entries.keys(), reverse=True): row = output.entries[k] date = row.get("Date\(Year-Month-Day Time\)", None) if not date: continue date_ = datetime.strptime(date, '%Y-%m-%d %H:%M:%S') # Save core info core_info = dict(module=row['Module'], pid=row['PID'], instance=row['Instance'], process=row['Process-name'], date=date.replace(" ", "_")) cores.append(core_info) return cores
def cli(self, output=None): parsed_dict = {} if output is None: out = self.device.execute(self.cli_command) else: out = output # REBOOT DATE TIME REBOOT REASON # ------------------------------------------------------------------------- # 2020-06-04T04:54:36+00:00 Initiated by user # 2020-06-16T09:19:57+00:00 Initiated by user # 2020-06-18T13:28:53+00:00 Initiated by user - activate 99.99.999-4542 # 2020-06-18T13:46:43+00:00 Software initiated - activate 99.99.999-4499 # 2020-06-18T14:03:24+00:00 Initiated by user - activate 99.99.999-4542 # 2020-06-18T14:20:11+00:00 Software initiated - activate 99.99.999-4499 # 2020-07-06T08:49:18+00:00 Initiated by user - activate 99.99.999-4567 if out: out = pg.oper_fill_tabular( device_output=out, header_fields=["REBOOT DATE TIME", "REBOOT REASON"], index=[0]) return_dict = out.entries reboot_date_time = {} for keys in return_dict.keys(): dict1 = {} dict1['reboot_reason'] = return_dict[keys]['REBOOT REASON'] reboot_date_time[keys] = dict1 parsed_dict['reboot_date_time'] = reboot_date_time return parsed_dict
def cli(self, output=None): if output is None: out = self.device.execute(self.cli_command) else: out = output # Interface Name Security # GigabitEthernet0/0 outside 0 header = ['Interface', 'Name', 'Security'] result = parsergen.oper_fill_tabular( device_output=out, device_os='asa', header_fields=header, index=[0] ) nameif_entries = result.entries line_dict = {} for k in nameif_entries.keys(): curr_dict = nameif_entries[k] interface_dict = line_dict.setdefault(k, {}) interface_dict.update({'interface': curr_dict['Interface']}) interface_dict.update({'name': curr_dict['Name']}) interface_dict.update({ 'security_level': int(curr_dict['Security']) }) return line_dict
def cli(self, output=None): if output is None: output = self.device.execute(self.cli_command) #Subscription ID Msgs Sent Msgs Drop Records Sent Connection Info #---------------- ---------- ---------- ------------ ----------------------------------------- #2147483648 246 0 126690 admin header = ["Subscription ID", "Msgs Sent", "Msgs Drop", "Records Sent", "Connection Info"] label_fields = ['sub_id', 'msg_sent', 'msg_drop', 'record_sent', 'connection_info'] ret_dict = dict() if output: tmp_dict = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, label_fields=label_fields, index=[0]).entries for k in tmp_dict: del tmp_dict[k]["sub_id"] ret_dict[int(k)] = tmp_dict[k] ret_dict[int(k)]["msg_sent"] = int(ret_dict[int(k)]["msg_sent"]) ret_dict[int(k)]["msg_drop"] = int(ret_dict[int(k)]["msg_drop"]) ret_dict[int(k)]["record_sent"] = int(ret_dict[int(k)]["record_sent"]) ret_dict = {"sub_id": ret_dict} return ret_dict
def cli(self, con_idx=None, output=None): if output is None: if con_idx: cmd = self.cli_command[1].format(con_idx=con_idx) else: cmd = self.cli_command[0] output = self.device.execute(cmd) ret_dict = dict() if output: #Index Peer Address Port VRF Source Address State State Description #----- -------------------------- ----- --- -------------------------- ---------- -------------------- # 0 5.40.26.169 49066 0 0.0.0.0 Active Connection created for protocol netconf # or #Index Peer Address Port VRF Source Address State State Description #----- -------------------------- ----- --- -------------------------- ---------- -------------------- # 0 5.40.26.169 49066 0 M 0.0.0.0 Active Connection created for protocol netconf header = ["Index", "Peer Address", "Port", "VRF", "Source Address", "State", "State Description"] label_fields = ["index", "peer_address", "port", "vrf", "source_address", "state", "state_description"] tmp_dict = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, label_fields=label_fields, index=[0]).entries for k in tmp_dict: del tmp_dict[k]["index"] ret_dict[int(k)] = tmp_dict[k] ret_dict[int(k)]["port"] = int(ret_dict[int(k)]["port"]) ret_dict[int(k)]["vrf"] = int(re.sub('M', '', ret_dict[int(k)]["vrf"])) ret_dict = {"index": ret_dict} return ret_dict
def cli(self, output=None): parsed_dict = {} if output is None: out = self.device.execute(self.cli_command) else: out = output # VERSION ACTIVE DEFAULT PREVIOUS CONFIRMED TIMESTAMP # --------------------------------------------------------------------------------- # 99.99.999-4499 false false true - 2020-06-01T03:30:46-00:00 # 99.99.999-4542 false false false - 2020-06-18T06:30:30-00:00 # 99.99.999-4567 true true false auto 2020-07-06T01:51:18-00:00 if out: out = pg.oper_fill_tabular(device_output=out, header_fields=[ "VERSION", "ACTIVE", "DEFAULT", "PREVIOUS", "CONFIRMED", "TIMESTAMP" ], label_fields=[ "version", "active", "default", "previous", "confirmed", "timestamp" ], index=[0]) return_dict = out.entries version_dict = {} for keys in return_dict.keys(): dict1 = {} del return_dict[keys]['version'] version_dict[keys] = return_dict[keys] parsed_dict['version'] = version_dict return parsed_dict
def get_arps(dev): """Retrieve the ARP entries from the device. ** As written only supports NX-OS devices. """ # Output from NX-OS Device # Flags: * - Adjacencies learnt on non-active FHRP router # + - Adjacencies synced via CFSoE # # - Adjacencies Throttled for Glean # CP - Added via L2RIB, Control plane Adjacencies # PS - Added via L2RIB, Peer Sync # RO - Re-Originated Peer Sync Entry # D - Static Adjacencies attached to down interface # # IP ARP Table for all contexts # Total number of entries: 1 # Address Age MAC Address Interface Flags # 10.0.2.2 00:04:55 5254.0012.3502 mgmt0 abstract = genie_prep(dev) nxos_arp_command = "show ip arp vrf all" arps = parsergen.oper_fill_tabular( device=dev, show_command=nxos_arp_command, header_fields=["Address", "Age", "MAC Address", "Interface", "Flags"], ) return arps.entries
def check_cores(device, core_list, **kwargs): # Init status = OK # Check if device is VDC try: output = device.parse('show vdc current-vdc') except Exception as e: logger.warning(e) meta_info = "Unable to execute 'show vdc current-vdc' to check if device is VDC" logger.error(meta_info) status = ERRORED(meta_info) return status # Check if device is VDC if 'current_vdc' in output and output['current_vdc']['id'] != '1': cmd = 'show cores' else: cmd = 'show cores vdc-all' # Execute command to check for cores header = [ "VDC", "Module", "Instance", "Process\-name", "PID", "Date\(Year\-Month\-Day Time\)" ] output = oper_fill_tabular(device=device, show_command=cmd, header_fields=header, index=[5]) if not output.entries: meta_info = "No cores found!" logger.info(meta_info) return OK(meta_info) # Parse through output to collect core information (if any) for k in sorted(output.entries.keys(), reverse=True): row = output.entries[k] date = row.get("Date\\(Year\\-Month\\-Day Time\\)", None) if not date: continue date_ = datetime.strptime(date, '%Y-%m-%d %H:%M:%S') # Save core info core_info = dict(module=row['Module'], pid=row['PID'], instance=row['Instance'], process=row['Process\\-name'], date=date.replace(" ", "_")) core_list.append(core_info) meta_info = "Core dump generated for process '{}' at {}".\ format(row['Process\\-name'], date_) logger.error(meta_info) status += CRITICAL(meta_info) return status
def pythonTabularParsing(self, uut, show_arp_header_fields, show_arp_table_title_pattern, show_arp_table_parse_index): """ Native Python Parsing of tabular CLI output""" res = pg.oper_fill_tabular(device=uut, show_command="SHOW_ARP", refresh_cache=True, header_fields=show_arp_header_fields, index = show_arp_table_parse_index, table_title_pattern = \ show_arp_table_title_pattern) log.info("Tabular parse result:\n" + pprint.pformat(res.entries))
def cli(self, vni=None, output=None): if output is None: cmd = self.cli_command[0] if vni: cmd = self.cli_command[1].format(vni=vni) output = self.device.execute(cmd) parsed_dict_vlan = oper_fill_tabular(header_fields=[ "Interface", "VNI", "Multicast-group", "VNI state", "Mode", "VLAN", "cfg", "vrf" ], label_fields=[ 'interface', 'vni', 'mcast', 'vni_state', 'mode', 'vlan', 'cfg', 'vrf' ], index=[0, 1], device_output=output, device_os='iosxe').entries if parsed_dict_vlan: return parsed_dict_vlan parsed_dict_bd = oper_fill_tabular(header_fields=[ "Interface", "VNI", "Multicast-group", "VNI state", "Mode", "BD", "cfg", "vrf" ], label_fields=[ 'interface', 'vni', 'mcast', 'vni_state', 'mode', 'bd', 'cfg', 'vrf' ], index=[0, 1], device_output=output, device_os='iosxe').entries return parsed_dict_bd
def cli(self, output=None): if output is None: out = self.device.execute(self.cli_command) else: out = output if not 'Flags' not in out: header = ['Address', 'Age', 'MAC Address', 'Interface'] else: header = ['Address', 'Age', 'MAC Address', 'Interface', 'Flags'] result = parsergen.oper_fill_tabular(device_output=out, device_os='nxos', header_fields=header, index=[0]) return result.entries
def test(self, steps): for device_name, device in self.execute_platform.items(): header=['flow_type','priority','sw_police_id','hw_policer_addr', 'Cur. Rate','burst','static_avgrate','avgrate_type', 'AggrAccepts','AggrDrops','TOS Value'] output = self.execute_platform[device_name] result = parsergen.oper_fill_tabular(device_output=output, device_os='iosxr', header_fields=header, index=[0]) output = result.entries logger.info(f"Structured Output from SHOW LPTS POLICER \n {output} ") police_drops = Dq(output).value_operator('AggrDrops', '>', 0).reconstruct() if police_drops == {}: self.passed(f"No issues found with drops on the lpts Policer") else: self.failed(f'Drops found on the control plane policer on the following processes:\n {police_drops.keys()}')
def cli(self,output=None): if output is None: out = self.device.execute(self.cli_command) else: out = output #Removing unneccessary header try: strout= re.findall(r'\s+[DST PUBLIC \s]+RX+\s+TX+\s',out) out=out.replace(strout[0],"") except: out=out #parsed output using parsergen parsed_out = pg.oper_fill_tabular(device_output=out, header_fields=["SYSTEM IP", "SITE ID", "COLOR", "STATE", "IP", "PORT", "ENCAP","TIME","PKTS","PKTS","DEL"], label_fields=["system_ip", "site_id", "color", "state", "dst_public_ip", "dst_public_port","encap","time","rx_pkts","tx_pkts","del"], index= [1,0,4,7] ) #creating a parsed dict using the output parsed_dict = parsed_out.entries #Parsing the dict according to the schema out_dict={} out_dict['site_id']={} cur_dict=out_dict['site_id'] for key in parsed_dict.keys(): cur_dict[key]={} cur_dict[key]['system_ip']={} for subkey in parsed_dict[key].keys(): cur_dict[key]['system_ip'][subkey]={} cur_dict[key]['system_ip'][subkey]['dst_public_ip']={} for subsubkey in parsed_dict[key][subkey].keys(): cur_dict[key]['system_ip'][subkey]['dst_public_ip'][subsubkey]={} cur_dict[key]['system_ip'][subkey]['dst_public_ip'][subsubkey]['time']={} for subsubsubkey in parsed_dict[key][subkey][subsubkey].keys(): cur_dict[key]['system_ip'][subkey]['dst_public_ip'][subsubkey]['time'][subsubsubkey]={} for valuekey in parsed_dict[key][subkey][subsubkey][subsubsubkey].keys(): if valuekey not in ['site_id','system_ip','dst_public_ip','time']: cur_dict[key]['system_ip'][subkey]['dst_public_ip'][subsubkey]['time'][subsubsubkey][valuekey]=parsed_dict[key][subkey][subsubkey][subsubsubkey][valuekey] return out_dict
def cli(self): # excute command to get output cmd = 'show nve peers' output = self.device.execute(cmd) header = [ 'Interface', 'VNI', 'Type', 'Peer-IP', 'Router-RMAC', 'eVNI', 'state', 'flags', 'UP time' ] result = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, index=[0]) return result.entries
def runGenieParser(content, columnheaders, index): # example columnheaders = ["Protocol", "Address", "Age (min)", "Hardware", "Addr", "Type", "Interface"] try: genie_resObj = parsergen.oper_fill_tabular( device_output=str(content), table_terminal_pattern=r"^\n", header_fields=columnheaders, index=index) except: # old python method, still works in Python 3 print('Error:', sys.exc_info()[1]) print('Error:', sys.exc_info()[1]) result = genie_resObj.entries resulttxt = json.dumps(result, indent=2) return resulttxt
def get_ospf_neighState(index_value, field, index=0): tb = load( '/home/dsalva/PycharmProjects/mse-cisco-R/mse-cisco/Resources/Source/InputFiles/testbed.yaml' ) dev = tb.devices['Automation-ASR9K-PE2'] dev.connect() output = dev.device.execute('show ospf neighbor') header = [ 'Neighbor ID', 'Pri', 'State', 'Dead Time', 'Address', 'Interface' ] result = oper_fill_tabular(device_output=output, device_os='iosxr', header_fields=header, index=index) state = result.entries[index_value][field] dev.disconnect() return state
def cli(self, output=None): if output is None: output = self.device.execute(self.cli_command) ret_dict = dict() if output: header = ["Name", "Type", "Profile", "State", "Explanation"] label_fields = [i.lower() for i in header] ret_dict = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, label_fields=label_fields, index=[0]).entries for k in ret_dict: del ret_dict[k]["name"] ret_dict = {"name": ret_dict} return ret_dict
def parse_cli(device): # By the default it will take cli output = device.execute('show interface brief') result = parsergen.oper_fill_tabular( device_output=output, device_os='nxos', header_fields=[[ 'Ethernet', 'VLAN', 'Type', 'Mode', 'Status', 'Reason', 'Speed', 'Port' ], ['Interface', '', '', '', '', '', '', 'Ch \#']], label_fields=[ 'Ethernet Interface', 'VLAN', 'Type', 'Mode', 'Status', 'Reason', 'Speed', 'Port' ], index=[0]) return result
def _nve_parse(self): output = self.device.execute('show nve vni') # Create list of Header names of the table from show nve nvi - must match exactly to that which is output on cli header = [ 'Interface', 'VNI', 'Multicast-group', 'VNI state', 'Mode', 'BD', 'cfg', 'vrf' ] # Use Parsergen to parse the output and create structured output (dictionary of operational stats) result = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, index=[0]) intlist = [x for x in result.entries] return intlist
def show_ip_eigrp_neighbors(uut): """ Parsing show ip eigrp neigbors using parsergen sample output EIGRP-IPv4 Neighbors for AS(100) H Address Interface Hold Uptime SRTT RTO Q Seq (sec) (ms) Cnt Num 1 10.1.1.3 Tu1 10 02:51:11 26 156 0 3 0 10.1.1.4 Tu1 12 02:51:12 5 100 0 4 """ # noqa # Use connect method to initiate connection to the device under test if not uut.is_connected(): uut.connect() # collect show command output command = 'show ip eigrp neighbors' output = uut.execute(command) try: headers = [ "H", "Address", "Interface", "Hold", "Uptime", "SRTT", "RTO", " Q ", "Seq" ] label_fields = [ "H", "Address", "Interface", "Uptime", "SRTT", "RTO", "QCnt", "SeqNum" ] eigrp_dict = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=headers, label_fields=label_fields, index=[1]) if '' in eigrp_dict.entries: del eigrp_dict.entries[''] return eigrp_dict.entries except Exception as e: pass
def cli(self, interface=None): # run the command to obtain the TEXT output so that we can then run it # through the parsergen. We do this because if the caller does not # provide an interface, or the provided interface is a range, we will # need to parse the same output multiple times; once for each interface # found in the output. cli_cmd = (self.cli_command[0] if not interface else self.cli_command[1].format(interface=interface)) oper_res = pg.oper_fill_tabular(device=self.device, show_command=cli_cmd, header_fields=self.OPER_TABLE_HEADERS, label_fields=self.OPER_TABLE_LABLES) # declare a dict variable that must returned from this method, and will # need to conform to the schema definition. schema_output = dict() if_names = list(oper_res.entries) if not if_names: return schema_output # perform second command to get the inventory CLI output, and then # parse for each interface name found from the first table parse. cli_inventory = self.device.execute("show inventory") for if_name in if_names: schema_output[if_name] = if_schema_data = {} data = parse_inventory_for_interface(if_name, cli_inventory) if not data: continue if_schema_data['type'] = data[f'{MARKUP_PREFIX}.type'] # vendor is not supported on this platform? if_schema_data['part_number'] = data[ f'{MARKUP_PREFIX}.part_number'] if_schema_data['serial_number'] = data[ f'{MARKUP_PREFIX}.serial_number'] return schema_output
def cli(self, output=None): parsed_dict = {} if output is None: out = self.device.execute(self.cli_command) else: out = output # App id State # --------------------------------------------------------- # utd RUNNING if out: out = pg.oper_fill_tabular(device_output=out, header_fields=["App id", "State"], index=[0]) return_dict = out.entries app_id = {} for keys in return_dict.keys(): app_dict = {} app_dict['state'] = return_dict[keys]['State'] app_id[keys] = app_dict parsed_dict['app_id'] = app_id return parsed_dict
def runGenieParser(self): content = self.teSource.toPlainText() cheaders = self.teTemplate.toPlainText() keystring = self.lineEdit.text() columnheaders = str(cheaders).split("\n") # columnheaders = ['Device ID', 'Local Intrfce', 'Holdtme', 'Capability', 'Platform', 'Port ID'] try: keys = int(keystring) res = parsergen.oper_fill_tabular(device_output=str(content), table_terminal_pattern=r"^\n", header_fields=columnheaders, index=keys) except: # old python method, still works in Python 3 print('Error:', sys.exc_info()[1]) print('Error:', sys.exc_info()[1]) result = res.entries resulttxt = json.dumps(result, indent=2) self.teResult.setPlainText(resulttxt)
def _parse_generic_tabular(cli_output, os, headers, key_index): # Boilerplate code to get the parser functional tb = Testbed() device = Device("new_device", os=os) device.custom.setdefault("abstraction", {})["order"] = ["os"] device.cli = AttrDict({"execute": None}) # Do the parsing # result = parsergen.oper_fill_tabular(device_output=cli_output, device_os=nos, header_ # fields=headers, index=[key]) result = parsergen.oper_fill_tabular(device_output=cli_output, device_os=os, header_fields=headers, index=key_index) # Structured data, but it has a blank entry because of the first line of the output # being blank under the headers. parsed_output = result.entries return parsed_output
def cli(self): # excute command to get output cmd = 'show nve vni' output = self.device.execute(cmd) header = [ 'Interface', 'VNI', 'Multicast-group', 'VNI state', 'Mode', 'BD', 'cfg', 'vrf' ] label = [ 'Interface', 'VNI', 'Multicast-group', 'VNIstate', 'Mode', 'BD', 'cfg', 'vrf' ] result = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, label_fields=label, index=[0]) return result.entries
def test(self, steps): print(path_store) for device_name, device in self.execute_cpu.items(): header = ['PID', '1Min', '5Min', '15Min', 'Process'] output = self.execute_cpu[device_name] output = re.sub('%', ' ', output) result = parsergen.oper_fill_tabular(device_output=output, device_os='iosxr', header_fields=header, index=[0]) output = result.entries cpu_bad = Dq(output).value_operator('5Min', '>=', 75).reconstruct() process_id = str(cpu_bad.keys()) if cpu_bad != {}: self.failed( f'Very High 5 Minute CPU detected on {device} with the following Process ID {process_id}' ) else: self.passed( f'No issues found with the CPU Utilisation on {device_name}' )
__license__ = "Cisco Sample Code License, Version 1.0" #Import Genie libraries from genie.conf import Genie from genie import parsergen import re from pprint import pprint #Create Testbed Object with Genie testbed = Genie.init('vagrant_multi_ios.yaml') #Create Device Object uut = testbed.devices.iosxe1 #Use connect method to initiate connection to the device under test uut.connect() #Execute command show nve nvi on connected device output = uut.device.execute('show nve vni') #Create list of Header names of the table from show nve nvi - must match exactly to that which is output on cli header = ['Interface', 'VNI', 'Multicast-group', 'VNI state', 'Mode', 'BD', 'cfg', 'vrf'] #Use Parsergen to parse the output and create structured output (dictionary of operational stats) result = parsergen.oper_fill_tabular(device_output=output, device_os='iosxe', header_fields=header, index=[0]) #Pretty Print the Dictionary pprint(result.entries)
from genie import testbed from genie import parsergen import pprint #load testbed file testbed = testbed.load('tbed2.yml') #choose IOS device and connect device = testbed.devices['R2'] device.connect() #Execute show interface summary command output = device.execute('show interface summary') # Parse tabular data result = parsergen.oper_fill_tabular(header_fields=[ "Interface", "IHQ", "IQD", "OHQ", "OQD", "RXBS", "RXPS", "TXBS", "TXPS", "TRTL" ], label_fields=[ "INTERFACE", "IHQ", "IQD", "OHQ", "OQD", "RXBS", "RXPS", "TXBS", "TXPS", "TRTL" ], index=[0], delimiter="*", device_output=output, device_os='ios') #Print the result pprint.pprint(result.entries)
def cli(self): """parsing mechanism: cli Function cli() defines the cli type output parsing mechanism which consists of the 3 steps: execution, transforming, returning """ parsed_dict = {} cmd = 'show ip sla summary' out = self.device.execute(cmd) #ID Type Destination Stats Return Last # Code Run #----------------------------------------------------------------------- #*1 tcp-connect 123.23.213.32 RTT=44 OK 21 seconds ag # o # # # #*2 dns 11.121.2.123 - Timeout 7 seconds ago if out: headers = [[ 'ID', 'Type', 'Destination', 'Stats', 'Return', 'Last' ], ['', '', '', '', 'Code', 'Run']] result = parsergen.oper_fill_tabular(device_output=out, header_fields=headers, label_fields=[ 'id', 'type', 'destination', 'rtt_stats_mseconds', 'return_code', 'last_run_seconds_ago' ]) struct_output = result.entries if struct_output: for id, id_dict in struct_output.items(): if id: # Defining patterns to be matched for different columns # The patterns for the state of the ip sla probe defined by the Codes: * active, ^ inactive, ~ pending active_pattern = re.compile(r'\*(\S+)') inactive_pattern = re.compile(r'\^(\S+)') pending_pattern = re.compile(r'\~(\S+)') # The pattern for the last_run_seconds_ago collumn last_run_pattern = re.compile(r'(\S+) sec\S+') # The pattern for the rtt_stats_mseconds (for milliseconds) # The first pattern is for normal RTT denoted in milliseconds and therefore would not require any further processing # The second pattern is for RTT denoted in microseconds and for standardisation purposes will be converted to milliseconds rtt_pattern_milliseconds = re.compile(r'RTT=(\d{1,4})') rtt_pattern_microseconds = re.compile( r'RTT=(\d{1,4})u') # Setting the probe_id and the codes values if active_pattern.match(id): probe_id = active_pattern.match(id).group(1) id_dict['probe_status'] = 'active' elif inactive_pattern.match(id): probe_id = inactive_pattern.match(id).group(1) id_dict['probe_status'] = 'inactive' elif pending_pattern.match(id): probe_id = pending_pattern.match(id).group(1) id_dict['probe_status'] = 'pending' del id_dict['id'] # Setting the rtt_stats_mseconds column value # If the value is in milliseconds if rtt_pattern_milliseconds.match( id_dict['rtt_stats_mseconds']): id_dict[ 'rtt_stats_mseconds'] = rtt_pattern_milliseconds.match( id_dict['rtt_stats_mseconds']).group(1) # If the value is in microseconds elif rtt_pattern_microseconds.match( id_dict['rtt_stats_mseconds']): id_dict['rtt_stats_mseconds'] = int( rtt_pattern_microseconds.match( id_dict['rtt_stats_mseconds']).group( 1)) / 1000 # If the value is a dash, no further processing is needed else: pass # Setting the value for the last_run_seconds_ago collumn if last_run_pattern.match( id_dict['last_run_seconds_ago']): id_dict[ 'last_run_seconds_ago'] = last_run_pattern.match( id_dict['last_run_seconds_ago']).group(1) parsed_dict.setdefault('id', {}).update({probe_id: id_dict}) else: # This else clause is added to mitigate the limitation that sometimes the cli output line for this command # may include just the letter 'o' as it would be cut from the Last Run column due to width limitation. pass return parsed_dict
# Create Device Object uut = testbed.devices['uut'] # Use connect method to initiate connection to the device under test uut.connect() # Execute command show nve nvi on connected device # Create list of Header names of the table from the show_command # these must match exactly to that which is output on cli header = ['System ID', 'SNPA', 'Level', 'State', 'Hold Time', 'Interface'] # Capture Before output before = uut.device.execute('show fabricpath isis adjacency') before = parsergen.oper_fill_tabular(device_output=before, device_os='nxos', header_fields=header, index=[0]) # Capture after output after = uut.device.execute('show fabricpath isis adjacency') after = parsergen.oper_fill_tabular(device_output=after, device_os='nxos', header_fields=header, index=[0]) pprint(after.entries) exclude = ['Hold Time'] dd = Diff(before.entries, after.entries, exclude=exclude) dd.findDiff() print(dd)