def get_interface_without_service_policy(device, interface_type, virtual_interface=False): """ Find a interface without service-policy Args: device (`obj`): Device object interface_type (`str`): Interface type virtual_interface ('bool'): flag for matching virtual interfaces Returns: None interface (`str`): Interface name Raises: None """ if not virtual_interface: p = re.compile(r"interface +(?P<intf>(?!\S+\.\S*)\S+)") else: p = re.compile(r"interface +(?P<intf>\S+)") config_dict = get_running_config_section_dict(device, "interface") for intf, config in config_dict.items(): if intf.startswith("interface " + interface_type): cfg = "\n".join(config) if "service-policy" not in cfg: try: return p.search(intf).groupdict()["intf"] except AttributeError: continue else: return
def verify_interface_description_in_running_config(device, interface, description): """Verify interface description in show running-config Args: device (`obj`): Device object interface (`str`): Interface name description (`str`): Interface description Returns: result(`bool`): verify result """ try: output = get_running_config_section_dict(device, interface + "$") except Exception as e: log.error(str(e)) raise Exception( "Failed to find interface {} through show running-config".format( interface)) intf = "interface {}".format(interface) desc = "description {}".format(description) try: result = isinstance(output[intf][desc], dict) except KeyError: return False return result
def verify_vrf_description_in_running_config(device, vrf, description): """Verify vrf description in show running-config Args: device (`obj`): Device object vrf (`str`): VRF name description (`str`): Description Returns: True False Raises: Exception KeyError """ try: output = get_running_config_section_dict(device, vrf + "$") except Exception as e: log.error(str(e)) raise Exception( "Failed to find vrf {vrf} through show running-config".format( vrf=vrf)) vrf = "vrf definition {vrf}".format(vrf=vrf) desc = "description {description}".format(description=description) try: result = isinstance(output[vrf][desc], dict) except KeyError: return False return result
def get_router_ospf_section_running_config(device, ospf_process_id): """ Get router OSPF section from running-config Args: device ('obj'): Device object ospf_process_id ('int'): OSPF router process id Returns: Dict with section """ section = "router ospf {ospf_process_id}".format( ospf_process_id=ospf_process_id) return get_running_config_section_dict(device=device, section=section)
def get_mpls_interface_ldp_configured(device): """ Get interfaces which have ldp configured from 'show run' Args: device ('obj'): Device object Returns: interface address """ interfaces = [] intf_dict = get_running_config_section_dict(device, "interface") p = re.compile(r"^interface +(?P<name>[\S\s]+)$") for intf, data_dict in intf_dict.items(): if "mpls label protocol ldp" in data_dict: m = p.match(intf) interfaces.append(m.groupdict()["name"]) return interfaces
def get_segment_routing_sid_map_configuration(device, address_family="ipv4"): """ Get Segment routing SID map configuration Args: device ('str'): Device str address_family ('str'): Address family Returns: Dictionary with ip address as key and sid as value ex.) { '192.168.1.1': '1', '192.168.1.2': '2' } """ out = get_running_config_section_dict( device=device, section="segment-routing" ) sid_dict = {} if not out: return None p1 = re.compile(r"^(?P<ip_address>\S+) index (?P<sid>\d+) range \d+$") connected_prefix_sid_maps = out["segment-routing mpls"][ "connected-prefix-sid-map" ]["address-family {}".format(address_family)].keys() for key in connected_prefix_sid_maps: key = key.strip() m = p1.match(key) if m: group = m.groupdict() sid_dict.update({group["ip_address"]: group["sid"]}) continue return sid_dict
def is_bgp_import_path_selection(device, vrf, selection_type, max_time=30, check_interval=10): """ Verifies that import path selection of type is in running config Args: device('obj'): device to use vrf('str'): vrf name selection_type('str'): import path selection type to verify max_time('int'): max time to wait check_interval('int'): how often to check Returns: True False Raises: None """ options = "vrf {}".format(vrf) log.info('Verifying "import path selection {}" is configured'.format( selection_type)) timeout = Timeout(max_time, check_interval) while timeout.iterate(): out = get_running_config_section_dict(device, section="router bgp", options=options) if has_configuration( out, "import path selection {}".format(selection_type)): return True timeout.sleep() return False
def configure_shut_bgp_neighbors(device, bgp_as, neighbors=None, address_family=None, vrf=None, noshut=False): """ Configures shut/enable on bgp neighbors if provided otherwise the ones found in running config Args: device ('obj'): device under test bgp_as ('int'): router bgp_as to configure on address_family ('str'): address_family to configure under vrf ('str'): vrf to configure under neighbors ('list'): List of neighbors to shut/enable noshut ('bool'): does the opposite of shut if True Returns: N/A Raises: SubCommandFailure: Failed executing configure commands ValueError: Some information is missing """ search = None if noshut: if neighbors: log.info("Enabling router bgp neighbors {}".format(neighbors)) elif address_family and vrf: log.info( "Enabling router bgp neighbors under address_family {} and vrf {}" .format(address_family, vrf)) search = "address-family {} vrf {}".format(address_family, vrf) elif address_family: log.info( "Enabling router bgp neighbors under address_family {}".format( address_family)) search = "address-family {}".format(address_family) else: if neighbors: log.info("Shutting down router bgp neighbors {}".format(neighbors)) elif address_family and vrf: log.info( "Shutting down router bgp neighbors under address_family {} and vrf {}" .format(address_family, vrf)) search = "address-family {} vrf {}".format(address_family, vrf) elif address_family: log.info( "Shutting down router bgp neighbors under address_family {}". format(address_family)) search = "address-family {}".format(address_family) p1_active_neighbor = re.compile( r"^neighbor +(?P<neighbor>[\d\.]+) +activate") p2_shutdown_neighbor = re.compile( r"^neighbor +(?P<neighbor>[\d\.]+) +shutdown") p3_neighbor = re.compile(r"^neighbor +(?P<neighbor>[\d\.]+)") cmd = "router bgp {}\n".format(bgp_as) if neighbors: if noshut: for neighbor in neighbors: cmd += "no neighbor {} shutdown".format(neighbor) else: for neighbor in neighbors: cmd += "neighbor {} shutdown".format(neighbor) try: device.configure(cmd) except SubCommandFailure: if noshut: raise SubCommandFailure("Could not enable bgp neighbors") else: raise SubCommandFailure("Could not shut bgp neighbors") else: already_shut = [] config_dict = get_running_config_section_dict(device, "router bgp") if config_dict: for sub_level in config_dict.get("router bgp {}".format(bgp_as), {}): # Following if/else block is used for neighbors under 'router bgp id' level if noshut: m = p2_shutdown_neighbor.match(sub_level) if m: cmd += "no neighbor {} shutdown\n".format( m.groupdict()["neighbor"]) else: m = p3_neighbor.match(sub_level) if m: if m.groupdict()["neighbor"] not in already_shut: already_shut.append(m.groupdict()["neighbor"]) cmd += "neighbor {} shutdown\n".format( m.groupdict()["neighbor"]) # Following if block is used for neighbors under address_family level if search and search in sub_level: # enter address-family cmd += sub_level + "\n" # shut / no shut neighbor for command in config_dict["router bgp {}".format( bgp_as)][sub_level]: if noshut: m = p2_shutdown_neighbor.match(command) if m: cmd += "no neighbor {} shutdown\n".format( m.groupdict()["neighbor"]) else: m = p1_active_neighbor.match(command) if m: cmd += "neighbor {} shutdown\n".format( m.groupdict()["neighbor"]) # exit address-family cmd += "exit-address-family\n" if "neighbor" in cmd: try: device.configure(cmd) except SubCommandFailure: if noshut: raise SubCommandFailure( "Could not enable bgp neighbors") else: raise SubCommandFailure("Could not shut bgp neighbors") else: if vrf: raise ValueError( "No neighbors found in running config " "under {} address_family and {} vrf.".format( address_family, vrf)) else: raise ValueError( "No neighbors found in running config " "under {} address_family.".format(address_family)) else: raise ValueError("No running configuration under router bgp.")