def interfaces(self, node): phy_loopback_zero = self.anm['phy'].interface(node.loopback_zero) if node.ip.use_ipv4: ipv4_loopback_subnet = netaddr.IPNetwork('0.0.0.0/32') ipv4_loopback_zero = phy_loopback_zero['ipv4'] ipv4_address = ipv4_loopback_zero.ip_address node.loopback_zero.use_ipv4 = True node.loopback_zero.ipv4_address = ipv4_address node.loopback_zero.ipv4_subnet = ipv4_loopback_subnet node.loopback_zero.ipv4_cidr = \ sn_preflen_to_network(ipv4_address, ipv4_loopback_subnet.prefixlen) if node.ip.use_ipv6: #TODO: clean this up so can set on router_base: call cidr not address and update templates node.loopback_zero.use_ipv6 = True ipv6_loopback_zero = phy_loopback_zero['ipv6'] node.loopback_zero.ipv6_address = \ sn_preflen_to_network(ipv6_loopback_zero.ip_address, 128) super(IosBaseCompiler, self).interfaces(node) for interface in node.physical_interfaces: interface.use_cdp = node.use_cdp # use node value
def interfaces(self, node): phy_loopback_zero = self.anm['phy' ].interface(node.loopback_zero) if node.ip.use_ipv4: ipv4_loopback_subnet = netaddr.IPNetwork('0.0.0.0/32') ipv4_loopback_zero = phy_loopback_zero['ipv4'] ipv4_address = ipv4_loopback_zero.ip_address node.loopback_zero.use_ipv4 = True node.loopback_zero.ipv4_address = ipv4_address node.loopback_zero.ipv4_subnet = ipv4_loopback_subnet node.loopback_zero.ipv4_cidr = \ sn_preflen_to_network(ipv4_address, ipv4_loopback_subnet.prefixlen) if node.ip.use_ipv6: # TODO: clean this up so can set on router_base: call cidr not # address and update templates node.loopback_zero.use_ipv6 = True ipv6_loopback_zero = phy_loopback_zero['ipv6'] node.loopback_zero.ipv6_address = \ sn_preflen_to_network(ipv6_loopback_zero.ip_address, 128) super(BrocadeBaseCompiler, self).interfaces(node) for interface in node.physical_interfaces(): interface.use_fdp = node.use_fdp # use node value for interface in node.interfaces: interface.sub_ints = [] # temporary until full subinterfaces
def interfaces(self, node): node.interfaces = [] node.loopback_zero.id = self.lo_interface node.loopback_zero.description = "Loopback" for interface in node.physical_interfaces: phy_int = self.anm['phy'].interface(interface) interface.physical = True #TODO: allocate ID in platform compiler if not phy_int: # for instance if added as management interface to nidb in compile continue interface.description = phy_int.description if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] #TODO: for consistency, make ipv6_cidr interface.ipv6_subnet = ipv6_int.subnet interface.ipv6_address = sn_preflen_to_network(ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) for interface in node.loopback_interfaces: #TODO: check if nonzero is different to __eq__ if interface == node.loopback_zero: continue else: #print "here for non zero", interface.id phy_int = self.anm['phy'].interface(interface) if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] interface.ipv4_address = ipv4_int.loopback interface.ipv4_subnet = node.loopback_subnet interface.ipv4_cidr = sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] #TODO: for consistency, make ipv6_cidr #interface.ipv6_subnet = ipv6_int.loopback # TODO: do we need for consistency? interface.ipv6_address = sn_preflen_to_network( ipv6_int.loopback, 128) # secondary loopbacks #TODO: check why vrf names not showing up for all #print vrf_interface.vrf_name pass continue
def copy_across_ip_addresses(self): log.info("Copying IP addresses to device model") # TODO: try/except and raise SystemError as fatal error if cant copy from autonetkit.ank import sn_preflen_to_network # TODO: check if this will clobber with platform? for node in self.nidb.l3devices(host=self.host): phy_node = self.anm['phy'].node(node) node.add_stanza("ip") node.ip.use_ipv4 = phy_node.use_ipv4 or False node.ip.use_ipv6 = phy_node.use_ipv6 or False for interface in node.interfaces: phy_int = phy_node.interface(interface) if phy_node.use_ipv4: ipv4_int = phy_int['ipv4'] if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue # TODO: also need to skip layer2 virtual interfaces # interface is connected try: interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) except AttributeError: log.warning( "Unable to copy across IPv4 for %s" % interface) else: interface.use_ipv4 = True if phy_node.use_ipv6: ipv6_int = phy_int['ipv6'] if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue try: # TODO: copy ip address as well interface.ipv6_subnet = ipv6_int.subnet interface.ipv6_address = sn_preflen_to_network(ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) except AttributeError: log.warning( "Unable to copy IPv6 subnet for %s" % interface) else: interface.use_ipv6 = True
def manual_ipv6_infrastructure_allocation(anm): """Applies manual IPv6 allocation""" import netaddr g_ipv6 = anm['ipv6'] g_in = anm['input'] log.info('Using specified IPv6 infrastructure allocation') for node in g_ipv6.l3devices(): for interface in node.physical_interfaces(): if not interface['input'].is_bound: continue # unbound interface if not interface['ipv6'].is_bound: continue ip_address = netaddr.IPAddress(interface['input' ].ipv6_address) prefixlen = interface['input'].ipv6_prefixlen interface.ip_address = ip_address interface.prefixlen = prefixlen cidr_string = '%s/%s' % (ip_address, prefixlen) interface.subnet = netaddr.IPNetwork(cidr_string) broadcast_domains = [d for d in g_ipv6 if d.broadcast_domain] # TODO: allow this to work with specified ip_address/subnet as well as # ip_address/prefixlen global_infra_block = None try: # Note this is only pickling up if explictly set in g_in infra_subnet = g_in.data.ipv6_infra_subnet infra_prefix = g_in.data.ipv6_infra_prefix global_infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: log.info("Unable to parse specified ipv4 infra subnets %s/%s")
def manual_ipv6_infrastructure_allocation(anm): """Applies manual IPv6 allocation""" import netaddr g_ipv6 = anm['ipv6'] g_in = anm['input'] log.info('Using specified IPv6 infrastructure allocation') for node in g_ipv6.l3devices(): for interface in node.physical_interfaces(): if not interface['input'].is_bound: continue # unbound interface if not interface['ipv6'].is_bound: continue ip_address = netaddr.IPAddress(interface['input'].ipv6_address) prefixlen = interface['input'].ipv6_prefixlen interface.ip_address = ip_address interface.prefixlen = prefixlen cidr_string = '%s/%s' % (ip_address, prefixlen) interface.subnet = netaddr.IPNetwork(cidr_string) broadcast_domains = [d for d in g_ipv6 if d.broadcast_domain] # TODO: allow this to work with specified ip_address/subnet as well as # ip_address/prefixlen global_infra_block = None try: # Note this is only pickling up if explictly set in g_in infra_subnet = g_in.data.ipv6_infra_subnet infra_prefix = g_in.data.ipv6_infra_prefix global_infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: log.info("Unable to parse specified ipv4 infra subnets %s/%s")
def extract_ipv6_blocks(anm): # TODO: set all these blocks globally in config file, rather than repeated # in load, build_network, compile, etc from autonetkit.ank import sn_preflen_to_network from netaddr import IPNetwork g_in = anm['input'] ipv6_defaults = SETTINGS["IP Addressing"]["v6"] try: infra_subnet = g_in.data.ipv6_infra_subnet infra_prefix = g_in.data.ipv6_infra_prefix infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, error: infra_block = IPNetwork( '%s/%s' % (ipv6_defaults["infra_subnet"], ipv6_defaults["infra_prefix"])) if infra_subnet is None or infra_prefix is None: log.debug('Using default IPv6 infra_subnet %s', infra_block) else: log.warning( 'Unable to obtain IPv6 infra_subnet from input graph: %s, using default %s' % (error, infra_block))
def interfaces(self, node): phy_loopback_zero = self.anm['phy' ].interface(node.loopback_zero) if node.ip.use_ipv4: ipv4_loopback_subnet = netaddr.IPNetwork('0.0.0.0/32') ipv4_loopback_zero = phy_loopback_zero['ipv4'] ipv4_address = ipv4_loopback_zero.ip_address node.loopback_zero.use_ipv4 = True node.loopback_zero.ipv4_address = ipv4_address node.loopback_zero.ipv4_subnet = ipv4_loopback_subnet node.loopback_zero.ipv4_cidr = \ sn_preflen_to_network(ipv4_address, ipv4_loopback_subnet.prefixlen) if node.ip.use_ipv6: # TODO: clean this up so can set on router_base: call cidr not # address and update templates node.loopback_zero.use_ipv6 = True ipv6_loopback_zero = phy_loopback_zero['ipv6'] node.loopback_zero.ipv6_address = \ sn_preflen_to_network(ipv6_loopback_zero.ip_address, 128) super(IosBaseCompiler, self).interfaces(node) for interface in node.physical_interfaces(): interface.use_cdp = node.use_cdp # use node value for interface in node.interfaces: interface.sub_ints = [] # temporary until full subinterfaces for interface in node.physical_interfaces(): g_ext_conn = self.anm['ext_conn'] if node not in g_ext_conn: continue node_ext_conn = g_ext_conn.node(node) ext_int = node_ext_conn.interface(interface) for sub_int in ext_int.sub_int or []: stanza = ConfigStanza( id=sub_int['id'], ipv4_address=sub_int['ipv4_address'], ipv4_prefixlen=sub_int['ipv4_prefixlen'], ipv4_subnet=sub_int['ipv4_subnet'], dot1q=sub_int['dot1q'], ) interface.sub_ints.append(stanza)
def interfaces(self, node): phy_loopback_zero = self.anm['phy'].interface(node.loopback_zero) if node.ip.use_ipv4: ipv4_loopback_subnet = netaddr.IPNetwork('0.0.0.0/32') ipv4_loopback_zero = phy_loopback_zero['ipv4'] ipv4_address = ipv4_loopback_zero.ip_address node.loopback_zero.use_ipv4 = True node.loopback_zero.ipv4_address = ipv4_address node.loopback_zero.ipv4_subnet = ipv4_loopback_subnet node.loopback_zero.ipv4_cidr = \ sn_preflen_to_network(ipv4_address, ipv4_loopback_subnet.prefixlen) if node.ip.use_ipv6: # TODO: clean this up so can set on router_base: call cidr not # address and update templates node.loopback_zero.use_ipv6 = True ipv6_loopback_zero = phy_loopback_zero['ipv6'] node.loopback_zero.ipv6_address = \ sn_preflen_to_network(ipv6_loopback_zero.ip_address, 128) super(IosBaseCompiler, self).interfaces(node) for interface in node.physical_interfaces(): interface.use_cdp = node.use_cdp # use node value for interface in node.interfaces: interface.sub_ints = [] # temporary until full subinterfaces for interface in node.physical_interfaces(): g_ext_conn = self.anm['ext_conn'] if node not in g_ext_conn: continue node_ext_conn = g_ext_conn.node(node) ext_int = node_ext_conn.interface(interface) for sub_int in ext_int.sub_int or []: stanza = ConfigStanza( id=sub_int['id'], ipv4_address=sub_int['ipv4_address'], ipv4_prefixlen=sub_int['ipv4_prefixlen'], ipv4_subnet=sub_int['ipv4_subnet'], dot1q=sub_int['dot1q'], ) interface.sub_ints.append(stanza)
def copy_across_ip_addresses(self): #TODO: try/except and raise SystemError as fatal error if cant copy from autonetkit.ank import sn_preflen_to_network #TODO: check if this will clobber with platform? for node in self.nidb.l3devices(host=self.host): phy_node = self.anm['phy'].node(node) node.add_stanza("ip") node.ip.use_ipv4 = phy_node.use_ipv4 or False node.ip.use_ipv6 = phy_node.use_ipv6 or False for interface in node.interfaces: phy_int = phy_node.interface(interface) if phy_node.use_ipv4: ipv4_int = phy_int['ipv4'] if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue # interface is connected interface.use_ipv4 = True interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = sn_preflen_to_network( interface.ipv4_address, interface.ipv4_subnet.prefixlen) if phy_node.use_ipv6: ipv6_int = phy_int['ipv6'] if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue interface.use_ipv6 = True try: #TODO: copy ip address as well interface.ipv6_subnet = ipv6_int.subnet interface.ipv6_address = sn_preflen_to_network( ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) except AttributeError: log.warning("Unable to copy IPv6 subnet for %s" % interface)
def interfaces(self, node): phy_loopback_zero = self.anm['phy'].interface(node.loopback_zero) if node.ip.use_ipv4: ipv4_loopback_subnet = netaddr.IPNetwork("0.0.0.0/32") ipv4_loopback_zero = phy_loopback_zero['ipv4'] ipv4_address = ipv4_loopback_zero.ip_address node.loopback_zero.ipv4_address = ipv4_address node.loopback_zero.ipv4_subnet = ipv4_loopback_subnet node.loopback_zero.ipv4_cidr = sn_preflen_to_network( ipv4_address, ipv4_loopback_subnet.prefixlen) if node.ip.use_ipv6: ipv6_loopback_zero = phy_loopback_zero['ipv6'] node.loopback_zero.ipv6_address = sn_preflen_to_network( ipv6_loopback_zero.ip_address, 128) super(IosBaseCompiler, self).interfaces(node) for interface in node.physical_interfaces: interface.use_cdp = node.use_cdp # use node value
def extract_ipv4_blocks(anm): #TODO: set all these blocks globally in config file, rather than repeated in load, build_network, compile, etc from autonetkit.ank import sn_preflen_to_network from netaddr import IPNetwork g_in = anm['input'] try: infra_subnet = g_in.data.ipv4_infra_subnet infra_prefix = g_in.data.ipv4_infra_prefix infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: log.debug("Unable to obtain infra_subnet from input graph: %s" % e) infra_block = IPNetwork("10.0.0.0/8")
def extract_ipv4_blocks(anm): # TODO: set all these blocks globally in config file, rather than repeated in load, build_network, compile, etc from autonetkit.ank import sn_preflen_to_network from netaddr import IPNetwork g_in = anm['input'] ipv4_defaults = SETTINGS["IP Addressing"]["v4"] try: infra_subnet = g_in.data.ipv4_infra_subnet infra_prefix = g_in.data.ipv4_infra_prefix infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: infra_block = IPNetwork('%s/%s' % (ipv4_defaults["infra_subnet"], ipv4_defaults["infra_prefix"])) log.warning('Unable to obtain IPv4 infra_subnet from input graph: %s, using default %s' % (e, infra_block))
def manual_ipv4_loopback_allocation(anm): """Applies manual IPv4 allocation""" import netaddr g_ipv4 = anm["ipv4"] g_in = anm["input"] for l3_device in g_ipv4.l3devices(): try: l3_device.loopback = IPAddress(l3_device["input"].loopback_v4) except netaddr.AddrFormatError: log.debug("Unable to parse IP address %s on %s", l3_device["input"].loopback_v6, l3_device) try: loopback_subnet = g_in.data.ipv4_loopback_subnet loopback_prefix = g_in.data.ipv4_loopback_prefix loopback_block = sn_preflen_to_network(loopback_subnet, loopback_prefix) except Exception, e: log.info("Unable to parse specified ipv4 loopback subnets %s/%s")
def manual_ipv4_loopback_allocation(anm): """Applies manual IPv4 allocation""" import netaddr g_ipv4 = anm['ipv4'] g_in = anm['input'] for l3_device in g_ipv4.l3devices(): try: l3_device.loopback = IPAddress(l3_device['input'].loopback_v4) except netaddr.AddrFormatError: log.debug("Unable to parse IP address %s on %s", l3_device['input'].loopback_v6, l3_device) try: loopback_subnet = g_in.data.ipv4_loopback_subnet loopback_prefix = g_in.data.ipv4_loopback_prefix loopback_block = sn_preflen_to_network(loopback_subnet, loopback_prefix) except Exception, e: log.info("Unable to parse specified ipv4 loopback subnets %s/%s")
def extract_ipv4_blocks(anm): # TODO: set all these blocks globally in config file, rather than repeated # in load, build_network, compile, etc from netaddr import IPNetwork g_in = anm["input"] ipv4_defaults = SETTINGS["IP Addressing"]["v4"] # TODO: wrap these in a common function try: infra_subnet = g_in.data.ipv4_infra_subnet infra_prefix = g_in.data.ipv4_infra_prefix infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: infra_block = IPNetwork("%s/%s" % (ipv4_defaults["infra_subnet"], ipv4_defaults["infra_prefix"])) if infra_subnet is None or infra_prefix is None: log.debug("Using default IPv4 infra_subnet %s" % infra_block) else: log.warning("Unable to obtain IPv4 infra_subnet from input graph: %s, using default %s" % (e, infra_block))
def manual_ipv4_infrastructure_allocation(anm): """Applies manual IPv4 allocation""" import netaddr g_ipv4 = anm["ipv4"] g_in = anm["input"] log.info("Using specified IPv4 infrastructure allocation") for node in g_ipv4.l3devices(): for interface in node.edge_interfaces(): if not interface["input"].is_bound: continue # unbound interface if not interface["ipv4"].is_bound: continue if interface["ip"].allocate is False: # TODO: copy interface allocate attribute across continue ip_address = netaddr.IPAddress(interface["input"].ipv4_address) prefixlen = interface["input"].ipv4_prefixlen interface.ip_address = ip_address interface.prefixlen = prefixlen cidr_string = "%s/%s" % (ip_address, prefixlen) interface.subnet = netaddr.IPNetwork(cidr_string) broadcast_domains = [d for d in g_ipv4 if d.broadcast_domain] # TODO: allow this to work with specified ip_address/subnet as well as # ip_address/prefixlen global_infra_block = None try: # Note this is only pickling up if explictly set in g_in infra_subnet = g_in.data.ipv4_infra_subnet infra_prefix = g_in.data.ipv4_infra_prefix global_infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: log.info("Unable to parse specified ipv4 infra subnets %s/%s")
def manual_ipv6_loopback_allocation(anm): """Applies manual IPv6 allocation""" import netaddr g_ipv6 = anm['ipv6'] g_in = anm['input'] for l3_device in g_ipv6.l3devices(): try: l3_device.loopback = IPAddress(l3_device['input'].loopback_v6) except netaddr.AddrFormatError: log.debug("Unable to parse IP address %s on %s", l3_device['input'].loopback_v6, l3_device) # also need to form aggregated IP blocks (used for e.g. routing prefix # advertisement) try: loopback_subnet = g_in.data.ipv6_loopback_subnet loopback_prefix = g_in.data.ipv6_loopback_prefix loopback_block = sn_preflen_to_network(loopback_subnet, loopback_prefix) except Exception, e: log.info("Unable to parse specified ipv4 loopback subnets %s/%s")
def interfaces(self, node): node.interfaces = [] node.loopback_zero.id = self.lo_interface node.loopback_zero.description = 'Loopback' phy_node = self.anm['phy'].node(node) node.loopback_zero.custom_config = phy_node.loopback_zero.custom_config if node.ip.use_ipv4: ipv4_node = self.anm['ipv4'].node(node) node.loopback_zero.ipv4_address = ipv4_node.loopback node.loopback_zero.ipv4_subnet = node.loopback_subnet #TODO: bne consistent wit hcidr name so can use in cisco ios xr templates #if node.ip.use_ipv6: #ipv6_node = self.anm['ipv6'].node(node) #node.loopback_zero.ipv6_address = ipv6_node.loopback #node.loopback_zero.ipv6_subnet = node.loopback_subnet for interface in node.physical_interfaces(): phy_int = self.anm['phy'].interface(interface) interface.physical = True # TODO: allocate ID in platform compiler if not phy_int: # for instance if added as management interface to nidb in compile continue interface.custom_config = phy_int.custom_config interface.description = phy_int.description remote_edges = phy_int.edges() if len(remote_edges): interface.description = 'to %s' \ % remote_edges[0].dst.label # TODO: fix the description to use mapped label if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] if ipv4_int.is_bound: # interface is connected interface.use_ipv4 = True interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = \ sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] if ipv6_int.is_bound: # interface is connected interface.use_ipv6 = True # TODO: for consistency, make ipv6_cidr interface.ipv6_subnet = ipv6_int.subnet try: interface.ipv6_address = \ sn_preflen_to_network(ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) except AttributeError: log.warning("Unable to format interface ") for interface in node.loopback_interfaces(): # TODO: check if nonzero is different to __eq__ if interface == node.loopback_zero: continue else: phy_int = self.anm['phy'].interface(interface) if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] interface.use_ipv4 = True interface.ipv4_address = ipv4_int.loopback interface.ipv4_subnet = node.loopback_subnet interface.ipv4_cidr = \ sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] interface.use_ipv6 = True # TODO: for consistency, make ipv6_cidr # interface.ipv6_subnet = ipv6_int.loopback # TODO: do we need for consistency? interface.ipv6_address = \ sn_preflen_to_network(ipv6_int.loopback, 128) # secondary loopbacks # TODO: check why vrf names not showing up for all # print vrf_interface.vrf_name continue
infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, error: infra_block = IPNetwork( '%s/%s' % (ipv6_defaults["infra_subnet"], ipv6_defaults["infra_prefix"])) if infra_subnet is None or infra_prefix is None: log.debug('Using default IPv6 infra_subnet %s', infra_block) else: log.warning( 'Unable to obtain IPv6 infra_subnet from input graph: %s, using default %s' % (error, infra_block)) try: loopback_subnet = g_in.data.ipv6_loopback_subnet loopback_prefix = g_in.data.ipv6_loopback_prefix loopback_block = sn_preflen_to_network(loopback_subnet, loopback_prefix) except Exception, error: loopback_block = IPNetwork('%s/%s' % (ipv6_defaults["loopback_subnet"], ipv6_defaults["loopback_prefix"])) if loopback_subnet is None or loopback_prefix is None: log.debug('Using default IPv6 loopback_subnet %s', loopback_block) else: log.warning( 'Unable to obtain IPv6 loopback_subnet from" input graph: %s, using default %s' % (error, loopback_block)) try: vrf_loopback_subnet = g_in.data.ipv6_vrf_loopback_subnet vrf_loopback_prefix = g_in.data.ipv6_vrf_loopback_prefix vrf_loopback_block = sn_preflen_to_network(vrf_loopback_subnet,
infra_subnet = g_in.data.ipv4_infra_subnet infra_prefix = g_in.data.ipv4_infra_prefix infra_block = sn_preflen_to_network(infra_subnet, infra_prefix) except Exception, e: infra_block = IPNetwork( '%s/%s' % (ipv4_defaults["infra_subnet"], ipv4_defaults["infra_prefix"])) if infra_subnet is None or infra_prefix is None: log.debug('Using default IPv4 infra_subnet %s' % infra_block) else: log.warning('Unable to obtain IPv4 infra_subnet from input graph: %s, using default %s' % ( e, infra_block)) try: loopback_subnet = g_in.data.ipv4_loopback_subnet loopback_prefix = g_in.data.ipv4_loopback_prefix loopback_block = sn_preflen_to_network(loopback_subnet, loopback_prefix) except Exception, e: loopback_block = IPNetwork( '%s/%s' % (ipv4_defaults["loopback_subnet"], ipv4_defaults["loopback_prefix"])) if loopback_subnet is None or loopback_prefix is None: log.debug('Using default IPv4 loopback_subnet %s' % loopback_block) else: log.warning('Unable to obtain IPv4 loopback_subnet from input graph: %s, using default %s' % ( e, loopback_block)) try: vrf_loopback_subnet = g_in.data.ipv4_vrf_loopback_subnet vrf_loopback_prefix = g_in.data.ipv4_vrf_loopback_prefix vrf_loopback_block = sn_preflen_to_network(vrf_loopback_subnet, vrf_loopback_prefix) except Exception, e:
def assign_management_interfaces(self): g_phy = self.anm['phy'] lab_topology = self.nidb.topology[self.host] oob_management_ips = {} #TODO: make this seperate function from netaddr import IPNetwork, IPRange mgmt_address_start = g_phy.data.mgmt_address_start mgmt_address_end = g_phy.data.mgmt_address_end mgmt_prefixlen = int(g_phy.data.mgmt_prefixlen) #TODO: need to check if range is insufficient mgmt_ips = (IPRange(mgmt_address_start, mgmt_address_end)) mgmt_ips_iter = iter(mgmt_ips) # to iterate over mgmt_address_start_network = IPNetwork(mgmt_address_start) # as /32 for supernet mgmt_address_end_network = IPNetwork(mgmt_address_end) # as /32 for supernet # retrieve the first supernet, as this is the range requested. subsequent are the subnets start_subnet = mgmt_address_start_network.supernet(mgmt_prefixlen)[0] # retrieve first end_subnet = mgmt_address_end_network.supernet(mgmt_prefixlen)[0] # retrieve first try: # validation assert(start_subnet == end_subnet) log.debug("Verified: Cisco management subnets match") except AssertionError: log.warning("Error: Cisco management subnets do not match: %s and %s, using start subnet" % (start_subnet, end_subnet)) mgmt_subnet = start_subnet hosts_to_allocate = sorted(self.nidb.nodes('is_router', host=self.host)) dhcp_subtypes = {"os"} dhcp_hosts = [h for h in hosts_to_allocate if h.device_subtype in dhcp_subtypes] non_dhcp_hosts = [h for h in hosts_to_allocate if h.device_subtype not in dhcp_subtypes] try: # validation assert(len(mgmt_ips) >= len(non_dhcp_hosts)) log.debug("Verified: Cisco management IP range is sufficient size %s for %s hosts" % (len(mgmt_ips), len(non_dhcp_hosts))) except AssertionError: log.warning("Error: Cisco management IP range is insufficient size %s for %s hosts" % (len(mgmt_ips), len(non_dhcp_hosts))) # TODO: need to use default range return for nidb_node in hosts_to_allocate: for interface in nidb_node.physical_interfaces: if interface.management: interface.description = "OOB Management" interface.physical = True if nidb_node in dhcp_hosts: interface.use_dhcp = True oob_management_ips[str(nidb_node)] = "dhcp" else: ipv4_address = mgmt_ips_iter.next() interface.ipv4_address = ipv4_address interface.ipv4_subnet = mgmt_subnet interface.ipv4_cidr = sn_preflen_to_network(ipv4_address, mgmt_prefixlen) oob_management_ips[str(nidb_node)] = ipv4_address lab_topology.oob_management_ips = oob_management_ips
def copy_across_ip_addresses(self): # log.info("Copying IP addresses to device model") # TODO: try/except and raise SystemError as fatal error if cant copy from autonetkit.ank import sn_preflen_to_network # TODO: check if this will clobber with platform? for node in self.nidb.l3devices(host=self.host): phy_node = self.anm['phy'].node(node) node.add_stanza("ip") node.ip.use_ipv4 = phy_node.use_ipv4 or False node.ip.use_ipv6 = phy_node.use_ipv6 or False for interface in node.interfaces: phy_int = phy_node.interface(interface) if phy_int.exclude_igp is not None: interface.exclude_igp = phy_int.exclude_igp if phy_node.use_ipv4: ipv4_int = phy_int['ipv4'] """ TODO: refactor this logic (and for ipv6) to only check if None then compilers are more pythonic - test for IP is None rather than bound etc - simplifies logic make try to copy, and if fail then warn and set use_ipv4 to False """ if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue # permit unbound ip interfaces (e.g. if skipped for l2 encap) if interface.is_physical and not ipv4_int.is_bound: interface.use_ipv4 = False continue if ipv4_int.ip_address is None: #TODO: put into dev log log.debug("No IP address allocated on %s", interface) interface.use_ipv4 = False continue # TODO: also need to skip layer2 virtual interfaces # interface is connected try: interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = sn_preflen_to_network( interface.ipv4_address, interface.ipv4_subnet.prefixlen) except AttributeError, error: log.warning("Unable to copy across IPv4 for %s" % interface) log.debug(error) else: interface.use_ipv4 = True if phy_node.use_ipv6: ipv6_int = phy_int['ipv6'] if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue # permit unbound ip interfaces (e.g. if skipped for l2 encap) if interface.is_physical and not ipv6_int.is_bound: interface.use_ipv6 = False continue if ipv6_int.ip_address is None: #TODO: put into dev log log.debug("No IP address allocated on %s", interface) interface.use_ipv6 = False continue try: # TODO: copy ip address as well interface.ipv6_subnet = ipv6_int.subnet interface.ipv6_address = sn_preflen_to_network( ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) except AttributeError: log.warning("Unable to copy IPv6 subnet for %s" % interface) else: interface.use_ipv6 = True
def interfaces(self, node): node.interfaces = [] node.loopback_zero.id = self.lo_interface node.loopback_zero.description = 'Loopback' phy_node = self.anm['phy'].node(node) node.loopback_zero.custom_config = phy_node.loopback_zero.custom_config if node.ip.use_ipv4: ipv4_node = self.anm['ipv4'].node(node) node.loopback_zero.ipv4_address = ipv4_node.loopback node.loopback_zero.ipv4_subnet = node.loopback_subnet #TODO: bne consistent wit hcidr name so can use in cisco ios xr templates #if node.ip.use_ipv6: #ipv6_node = self.anm['ipv6'].node(node) #node.loopback_zero.ipv6_address = ipv6_node.loopback #node.loopback_zero.ipv6_subnet = node.loopback_subnet for interface in node.physical_interfaces: phy_int = self.anm['phy'].interface(interface) interface.physical = True # TODO: allocate ID in platform compiler if not phy_int: # for instance if added as management interface to nidb in compile continue interface.custom_config = phy_int.custom_config interface.description = phy_int.description remote_edges = phy_int.edges() if len(remote_edges): interface.description = 'to %s' \ % remote_edges[0].dst.label # TODO: fix the description to use mapped label if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] if ipv4_int.is_bound: # interface is connected interface.use_ipv4 = True interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = \ sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] if ipv6_int.is_bound: # interface is connected interface.use_ipv6 = True # TODO: for consistency, make ipv6_cidr interface.ipv6_subnet = ipv6_int.subnet try: interface.ipv6_address = \ sn_preflen_to_network(ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) except AttributeError: log.warning("Unable to format interface ") for interface in node.loopback_interfaces: # TODO: check if nonzero is different to __eq__ if interface == node.loopback_zero: continue else: phy_int = self.anm['phy'].interface(interface) if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] interface.use_ipv4 = True interface.ipv4_address = ipv4_int.loopback interface.ipv4_subnet = node.loopback_subnet interface.ipv4_cidr = \ sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] interface.use_ipv6 = True # TODO: for consistency, make ipv6_cidr # interface.ipv6_subnet = ipv6_int.loopback # TODO: do we need for consistency? interface.ipv6_address = \ sn_preflen_to_network(ipv6_int.loopback, 128) # secondary loopbacks # TODO: check why vrf names not showing up for all # print vrf_interface.vrf_name continue
def interfaces(self, node): node.interfaces = [] node.loopback_zero.id = self.lo_interface node.loopback_zero.description = "Loopback" for interface in node.physical_interfaces: phy_int = self.anm['phy'].interface(interface) interface.physical = True #TODO: allocate ID in platform compiler if not phy_int: # for instance if added as management interface to nidb in compile continue interface.description = phy_int.description remote_edges = phy_int.edges() if len(remote_edges): interface.description = "to %s" % remote_edges[0].dst.label #TODO: fix the description to use mapped label if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] if ipv4_int.is_bound: # interface is connected interface.use_ipv4 = True interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] if ipv6_int.is_bound: # interface is connected interface.use_ipv6 = True #TODO: for consistency, make ipv6_cidr interface.ipv6_subnet = ipv6_int.subnet interface.ipv6_address = sn_preflen_to_network(ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) for interface in node.loopback_interfaces: #TODO: check if nonzero is different to __eq__ if interface == node.loopback_zero: continue else: phy_int = self.anm['phy'].interface(interface) if node.ip.use_ipv4: ipv4_int = phy_int['ipv4'] interface.use_ipv4 = True interface.ipv4_address = ipv4_int.loopback interface.ipv4_subnet = node.loopback_subnet interface.ipv4_cidr = sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) if node.ip.use_ipv6: ipv6_int = phy_int['ipv6'] interface.use_ipv6 = True #TODO: for consistency, make ipv6_cidr #interface.ipv6_subnet = ipv6_int.loopback # TODO: do we need for consistency? interface.ipv6_address = sn_preflen_to_network( ipv6_int.loopback, 128) # secondary loopbacks #TODO: check why vrf names not showing up for all #print vrf_interface.vrf_name continue
def copy_across_ip_addresses(self): # log.info("Copying IP addresses to device model") # TODO: try/except and raise SystemError as fatal error if cant copy from autonetkit.ank import sn_preflen_to_network # TODO: check if this will clobber with platform? for node in self.nidb.l3devices(host=self.host): phy_node = self.anm['phy'].node(node) node.add_stanza("ip") node.ip.use_ipv4 = phy_node.use_ipv4 or False node.ip.use_ipv6 = phy_node.use_ipv6 or False for interface in node.interfaces: phy_int = phy_node.interface(interface) if phy_int.exclude_igp is not None: interface.exclude_igp = phy_int.exclude_igp if phy_node.use_ipv4: ipv4_int = phy_int['ipv4'] """ TODO: refactor this logic (and for ipv6) to only check if None then compilers are more pythonic - test for IP is None rather than bound etc - simplifies logic make try to copy, and if fail then warn and set use_ipv4 to False """ if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue # permit unbound ip interfaces (e.g. if skipped for l2 encap) if interface.is_physical and not ipv4_int.is_bound: interface.use_ipv4 = False continue if ipv4_int.ip_address is None: #TODO: put into dev log log.debug("No IP address allocated on %s", interface) interface.use_ipv4 = False continue # TODO: also need to skip layer2 virtual interfaces # interface is connected try: interface.ipv4_address = ipv4_int.ip_address interface.ipv4_subnet = ipv4_int.subnet interface.ipv4_cidr = sn_preflen_to_network(interface.ipv4_address, interface.ipv4_subnet.prefixlen) except AttributeError, error: log.warning( "Unable to copy across IPv4 for %s" % interface) log.debug(error) else: interface.use_ipv4 = True if phy_node.use_ipv6: ipv6_int = phy_int['ipv6'] if node.is_server() and interface.is_loopback: continue if interface.is_physical and not interface.is_bound: continue # permit unbound ip interfaces (e.g. if skipped for l2 encap) if interface.is_physical and not ipv6_int.is_bound: interface.use_ipv6 = False continue if ipv6_int.ip_address is None: #TODO: put into dev log log.debug("No IP address allocated on %s", interface) interface.use_ipv6 = False continue try: # TODO: copy ip address as well interface.ipv6_subnet = ipv6_int.subnet interface.ipv6_address = sn_preflen_to_network(ipv6_int.ip_address, interface.ipv6_subnet.prefixlen) except AttributeError: log.warning( "Unable to copy IPv6 subnet for %s" % interface) else: interface.use_ipv6 = True