def test_choose_port_not_overloaded(self): """Don't pick the port that will be overloaded.""" self.mech.networks = { 'host1': { 'port0': { 'zone1': (IPNetwork('101::/64'), 101, []) }, 'port1': { 'zone1': (IPNetwork('201::/64'), 201, []) }, 'port2': { 'zone1': (IPNetwork('301::/64'), 301, []) } } } self.mech.allocated_bandwidth = { ('host1', 'port0'): { 'p1': 1 }, ('host1', 'port1'): { 'p2': 6 }, ('host1', 'port1'): { 'p2': 0 } } port = self.mech._choose_port('host1', 'zone1', 6, 5) self.assertNotEqual(port, 'port1')
def add(self, addr, flags=0): """ Adds an IP address or subnet or IPRange to this IP set. Has no effect if it is already present. Note that where possible the IP address or subnet is merged with other members of the set to form more concise CIDR blocks. :param addr: An IP address or subnet in either string or object form, or an IPRange object. :param flags: decides which rules are applied to the interpretation of the addr value. See the netaddr.core namespace documentation for supported constant values. """ if isinstance(addr, IPRange): new_cidrs = dict.fromkeys(iprange_to_cidrs(addr[0], addr[-1]), True) self._cidrs.update(new_cidrs) self.compact() return if isinstance(addr, IPNetwork): # Networks like 10.1.2.3/8 need to be normalized to 10.0.0.0/8 addr = addr.cidr elif isinstance(addr, _int_type): addr = IPNetwork(IPAddress(addr, flags=flags)) else: addr = IPNetwork(addr) self._cidrs[addr] = True self._compact_single_network(addr)
def randomipv6(cls, subnet='2001::', prefix=64): random.seed() ipv6_address = IPAddress(subnet) + random.getrandbits(16) ipv6_network = IPNetwork(ipv6_address) ipv6_network.prefixlen = prefix output = '{},{}'.format(ipv6_address, ipv6_network) return '{}'.format(ipv6_address), '{}'.format(ipv6_network)
def test_choose_port_loaded(self): """Pick the most loaded port that has capacity available.""" self.mech.networks = { 'host1': { 'port0': { 'zone1': (IPNetwork('101::/64'), 101, []) }, 'port1': { 'zone1': (IPNetwork('201::/64'), 201, []) }, 'port2': { 'zone1': (IPNetwork('301::/64'), 301, []) } } } self.mech.allocated_bandwidth = { ('host1', 'port0'): { 'p1': 0 }, ('host1', 'port1'): { 'p2': 1 }, ('host1', 'port2'): { 'p3': 0 } } port = self.mech._choose_port('host1', 'zone1', 6, 5) self.assertEqual(port, 'port1')
def test_choose_least_overloaded_ipv6(self): """Pick the least-overloaded port.""" self.mech.networks = { 'host1': { 'port0': { 'zone1': (IPNetwork('101::/64'), 101, []) }, 'port1': { 'zone1': (IPNetwork('201::/64'), 201, []) }, 'port2': { 'zone1': (IPNetwork('301::/64'), 301, []) } } } self.mech.allocated_bandwidth = { ('host1', 'port0'): { 'p1': 99 }, ('host1', 'port1'): { 'p2': 42 }, ('host1', 'port2'): { 'p3': 76 } } port = self.mech._choose_port('host1', 'zone1', 6, 5) self.assertEqual(port, 'port1')
def update(self, data): """ Callback function used by Publisher to notify this Subscriber about an update. Stores topic based information into dictionary passed to constructor. """ data_id = data[self.unique_key] if self.topic == 'IPv4': cidr = IPNetwork(cidr_abbrev_to_verbose(data_id)) self.dct[cidr] = data elif self.topic == 'IPv6': cidr = IPNetwork(cidr_abbrev_to_verbose(data_id)) self.dct[cidr] = data elif self.topic == 'multicast': iprange = None if '-' in data_id: # See if we can manage a single CIDR. (first, last) = data_id.split('-') iprange = IPRange(first, last) cidrs = iprange.cidrs() if len(cidrs) == 1: iprange = cidrs[0] else: iprange = IPAddress(data_id) self.dct[iprange] = data
def create_prefix(bridges, vlan_init, vfw_prefix_init, local_prefix_init, num): global host_serial_number hosts = [] for current in range(1, num + 1): host_serial_number += 1 if current == 1: vlan = vlan_init vfw_prefix = vfw_prefix_init local_prefix = local_prefix_init else: vlan += 1 vfw_subnet = IPNetwork(vfw_prefix) vfw_ipaddr = vfw_subnet.ip + 256 * 256 vfw_mask = vfw_subnet.netmask vfw_prefix = IPNetwork(str(vfw_ipaddr) + '/' + str(vfw_mask)) local_subnet = IPNetwork(local_prefix) local_ipaddr = local_subnet.ip + 256 * 256 local_mask = local_subnet.netmask local_prefix = IPNetwork(str(local_ipaddr) + '/' + str(local_mask)) host = "host_%03d_%03d" % (host_serial_number, vlan) hostname = Container(host, vlan, bridges, vfw_prefix, local_prefix, 5) hosts.append(hostname) [host.run() for host in hosts]
def test_choose_least_overloaded_ipv4_2(self): """Pick the least-overloaded port when there is IPv4 zone.""" self.mech.networks = { 'host1': { 'port0': { 'zone1': (IPNetwork('101::/64'), 101, []) }, 'port1': { 'zone1': (IPNetwork('102::/64'), 101, []), 'zone2': (IPNetwork('192.168.201.0/24'), 201, []) }, 'port2': { 'zone1': (IPNetwork('301::/64'), 301, []) } } } self.mech.allocated_bandwidth = { ('host1', 'port0'): { 'p1': 1 }, ('host1', 'port1'): { 'p2': 0 }, ('host1', 'port2'): { 'p3': 2 } } port = self.mech._choose_port('host1', 'zone1', 6, 5) self.assertEqual(port, 'port2')
def add_link_for_wan(self, host, serial, hostip): subnet = IPNetwork(hostip) ipaddr = subnet.ip + 2 mask = subnet.netmask prefix = IPNetwork(str(ipaddr) + '/' + str(mask)) br_name = "br%03d" % serial + '-0' ifname = 'eth0' self.pipework(br_name, ifname, host, prefix)
def test_ip_splitter_remove_same_input_range(): s = SubnetSplitter('172.24.0.0/16') assert s.available_subnets() == [IPNetwork('172.24.0.0/16')] assert s.extract_subnet(16, count=1) == [ IPNetwork('172.24.0.0/16'), ] assert s.available_subnets() == []
def setupDataplaneForRemoteEndpoint(self, prefix, remotePE, label, nlri, encaps): dec_ttl_action = "" if IPNetwork(repr(prefix)) not in IPNetwork("%s/%s" % (self.gatewayIP, self.mask)): dec_ttl_action = "dec_ttl" label_action = "push_mpls:0x8847,load:%s->OXM_OF_MPLS_LABEL[]" % label # Check if prefix is from a local VRF if self.driver.getLocalAddress() == str(remotePE): self.log.debug("Local route, using a resubmit action") # For local traffic, we have to use a resubmit action output_action = "resubmit:%s" % self._mplsInPort() else: if (self.driver.vxlanEncap and Encapsulation(Encapsulation.VXLAN) in encaps): self.log.debug("Will use a VXLAN encap for this destination") output_action = "set_field:%s->tun_dst,output:%s" % ( str(remotePE), self.driver.ovsVXLANTunnelPortNumber) label_action = "set_field:%d->tunnel_id" % label # OR set_field:0xfoo->tun_id ? elif self.driver.useGRE: self.log.debug("Using MPLS/GRE encap") output_action = "set_field:%s->tun_dst,output:%s" % ( str(remotePE), self.driver.ovsGRETunnelPortNumber) else: self.log.debug("Using bare MPLS encap") # Find remote router MAC address try: remotePE_mac_address = self._find_remote_mac_address( remotePE) self.log.debug("MAC address found for remote router " "%(remotePE)s: %(remotePE_mac_address)s", locals()) except exc.RemotePEMACAddressNotFound as e: self.log.error("An error occured during setupDataplaneFor" "RemoteEndpoint: %s", e) # Map traffic to remote IP address as MPLS on ethX to remote # router MAC address output_action = "mod_dl_src:%s,mod_dl_dst:%s,output:%s" % ( self.mplsIfMacAddress, remotePE_mac_address, self.driver.ovsMplsIfPortNumber) # Check if prefix is a default route nw_dst_match = "" if IPNetwork(repr(prefix)).prefixlen != 0: nw_dst_match = ',nw_dst=%s' % prefix self._ovs_flow_add( 'ip,in_port=%s%s' % (self.patchPortInNumber, nw_dst_match), ','.join(filter(None, (dec_ttl_action, label_action, output_action))), self.driver.ovs_table_vrfs)
def add_link_for_lan(self, host, serial, hostip, num): for i in range(num): subnet = IPNetwork(hostip) ipaddr = subnet.ip + (256 * i) + 1 mask = subnet.netmask prefix = IPNetwork(str(ipaddr) + '/' + str(mask)) br_name = "br%03d" % serial + '-' + str(i + 1) ifname = 'eth' + str(i + 1) self.pipework(br_name, ifname, host, prefix)
def add_link_for_tenant(self, host, vlan, tenant_ip, tenant_num): for i in range(tenant_num): subnet = IPNetwork(tenant_ip) ipaddr = subnet.ip + (256 * i) + 1 mask = subnet.netmask prefix = IPNetwork(str(ipaddr) + '/' + str(mask)) br_name = 'br' + str(vlan) + '-' + str(i + 1) if_name = 'eth' + str(i) self.pipework(br_name, if_name, host, prefix)
def discover_subrede(self, ip_addr, mask): network = IPNetwork('/'.join([ip_addr, mask])) generator = network.iter_hosts() session = sessions.FuturesSession() futures = [ session.get("http://{}:{}/{}/{}".format(self.endpoint, self.wsgi_port, self.discovery_path, ip)) for ip in list(generator) ] return
def find_in_routingTable (self, dstIp): ruta_sel = [IPNetwork('0.0.0.0/0'),0,None] for ruta in self.tablaEnrutamiento: if IPAddress(ruta[0]) == (IPAddress(dstIp) & IPAddress(ruta[1])): if int(ruta_sel[0].prefixlen) < int(IPAddress(ruta[1])): ruta_sel[0] = IPNetwork(ruta[0],ruta[1]) #Network ruta_sel[1] = ruta[2] #Puerto ruta_sel[2] = ruta[3] #Gateway # print "ruta sel: ", ruta_sel if ruta_sel[2] == None: return (dstIp, ruta_sel[1]) else: return (ruta[ruta_sel[2]], ruta_sel[1])
def add_flow_gateway_push_mpls(self, datapath, ethertype, routeDist, label, mod_srcMac, mod_dstMac, outPort, defaultIpAddr): ipaddress = IPNetwork("0.0.0.0" + '/' + "0.0.0.0") prefix = str(ipaddress.cidr) vpnv4_prefix = routeDist + ':' + prefix LOG.debug("add MplsInfo(%s, [%s])"%(vpnv4_prefix, label)) self.mplsInfo[vpnv4_prefix] = MplsTable(routeDist, prefix, label, "0.0.0.0", "0.0.0.0", defaultIpAddr) match = datapath.ofproto_parser.OFPMatch(eth_type=ethertype) actions =[datapath.ofproto_parser.OFPActionPushMpls(0x8847), datapath.ofproto_parser.OFPActionSetField(eth_src=mod_srcMac), datapath.ofproto_parser.OFPActionSetField(eth_dst=mod_dstMac), datapath.ofproto_parser.OFPActionSetField(mpls_label=label), datapath.ofproto_parser.OFPActionSetField(mpls_tc=1), datapath.ofproto_parser.OFPActionOutput(outPort, 0), datapath.ofproto_parser.OFPActionSetMplsTtl(255), datapath.ofproto_parser.OFPActionDecMplsTtl()] inst = [datapath.ofproto_parser.OFPInstructionActions( datapath.ofproto.OFPIT_APPLY_ACTIONS, actions)] mod = datapath.ofproto_parser.OFPFlowMod( cookie=0, cookie_mask=0, table_id=0, command=datapath.ofproto.OFPFC_ADD, datapath=datapath, idle_timeout=0, hard_timeout=0, priority=0x1, buffer_id=0xffffffff, out_port=datapath.ofproto.OFPP_ANY, out_group=datapath.ofproto.OFPG_ANY, match=match, instructions=inst) datapath.send_msg(mod)
def _parse_ipaddress_prefix(self, cidr): try: net = IPNetwork(cidr) return (str(net.ip), net.prefixlen) except AddrFormatError: raise exc.SfcDriverError(message=( "Malformed IP prefix: %s" % cidr))
def getIfaceInfo(ipNetworkOrAddress): ''' Determine interface information of the local interfaces an IP address or network belongs to. @param ipNetworkOrAddress: IP network or address matching the configured network of the wanted interfaces. ''' if isinstance(ipNetworkOrAddress, IPAddress): LOG.info('Getting interface info for address %s' % str(ipNetworkOrAddress)) elif isinstance(ipNetworkOrAddress, IPNetwork): LOG.info('Getting interface info for network %s' % ipNetworkOrAddress.ip) else: raise BaseException( 'ipNetworkOrAddress must be netaddr IPAddress or IPNetwork') matchingIfaceInfos = [] for ifaceInfo in ifaces.itervalues(): network = IPNetwork(str(ifaceInfo.dnetdict['addr'])) netIps = list(network) if ipNetworkOrAddress in netIps: matchingIfaceInfos.append(ifaceInfo) if len(matchingIfaceInfos) == 0: raise BaseException('No interface with a matching IP settings found') return matchingIfaceInfos
def priority_for_ipaddr(ipaddr, base=PRIORITY_BASE): """ priority of flow entry. """ from netaddr.ip import IPNetwork ipnw = IPNetwork(ipaddr) return ipnw.prefixlen * PRIORITY_BAND + base
def sendWhoIs(src, dst, count=1): ''' @param dst: Destination IP or network @todo: Use matching interface IP as src ''' bindLayers() try: ipDst = IPNetwork(dst) dst = str(ipDst.broadcast) except: ipDst = IPAddress(dst) udp = IP(src=src, dst=dst) / UDP(sport=BACNET_PORT, dport=BACNET_PORT) bvlcBase = getBvlcBase(ipDst) bvlc = udp / BVLC(**bvlcBase) npduBase = getNpduBase(withApdu=True) npdu = bvlc / NPDU(**npduBase) apdu = npdu / APDU(pdu_type=PduType.UNCONFIRMED_REQUEST, service_choice=UnconfirmedServiceChoice.WHO_IS) # sendp(): no packets on the wire?! # srloop(): How to match answer to request? send(apdu, count=count)
def add_flow_gateway(self, datapath, ethertype, mod_srcMac, mod_dstMac, outPort, defaultGateway): ipaddress = IPNetwork("0.0.0.0" + '/' + "0.0.0.0") prefix = str(ipaddress.cidr) LOG.debug("add RoutingInfo(gateway) for %s" % prefix) self.routingInfo[prefix] = RoutingTable(prefix, "0.0.0.0", "0.0.0.0", defaultGateway) match = datapath.ofproto_parser.OFPMatch(eth_type=ethertype) actions = [ datapath.ofproto_parser.OFPActionSetField(eth_src=mod_srcMac), datapath.ofproto_parser.OFPActionSetField(eth_dst=mod_dstMac), datapath.ofproto_parser.OFPActionOutput(outPort, 0), datapath.ofproto_parser.OFPActionDecNwTtl() ] inst = [ datapath.ofproto_parser.OFPInstructionActions( datapath.ofproto.OFPIT_APPLY_ACTIONS, actions) ] mod = datapath.ofproto_parser.OFPFlowMod( cookie=0, cookie_mask=0, table_id=0, command=datapath.ofproto.OFPFC_ADD, datapath=datapath, idle_timeout=0, hard_timeout=0, priority=0x1, buffer_id=0xffffffff, out_port=datapath.ofproto.OFPP_ANY, out_group=datapath.ofproto.OFPG_ANY, match=match, instructions=inst) datapath.send_msg(mod) return 0
def announceRoutes(n): if ipVersion is 'ipv4': target = 'announce route 100.0.0.0/24 next-hop 90.0.0.1' FIR = 1 SEC = 0 THI = 0 # generate n random ipv4 addresses and create a list for i in range(0, n): messages.append("announce route " + str(FIR) + "." + str(SEC) + "." + str(THI) + ".0/24" + " next-hop 90.0.0.1") THI = THI + 1 if THI == 254: SEC = SEC + 1 THI = 0 if SEC == 254: FIR = FIR + 1 SEC = 0 else: target = 'announce route 10::/64 next-hop 90::1' # generate n random ipv6 addresses for i in range(0, n): random.seed(i) ip_a = IPAddress('2001::cafe:0') + random.getrandbits(16) ip_n = IPNetwork(ip_a) messages.append('announce route ' + str(ip_n) + ' 90::1') # target at beginning or end of list if append == "first": messages.inser(0, target) else: messages.append(target) return messages
def __init__(self, options, session): """ Ctor. :param options: Options for path service from configuration. :type options: dict :param session: Instance of `ApplicationSession` to be used for forwarding events. :type session: obj """ Resource.__init__(self) self._options = options self._session = session self.log = make_logger() self._key = None if 'key' in options: self._key = options['key'].encode('utf8') self._secret = None if 'secret' in options: self._secret = options['secret'].encode('utf8') self._post_body_limit = int(options.get('post_body_limit', 0)) self._timestamp_delta_limit = int( options.get('timestamp_delta_limit', 300)) self._require_ip = None if 'require_ip' in options: self._require_ip = [ IPNetwork(net) for net in options['require_ip'] ] self._require_tls = options.get('require_tls', None)
def _findTree(self, ip): """ returns the tree containing <ip> ip in integer or string format """ ipnw = IPNetwork(str(IPAddress(ip)) + self.netmask).first return self.forest[ipnw]
def __init__(self, iterable=None, flags=0): """ Constructor. :param iterable: (optional) an iterable containing IP addresses and subnets. :param flags: decides which rules are applied to the interpretation of the addr value. See the netaddr.core namespace documentation for supported constant values. """ if isinstance(iterable, IPNetwork): self._cidrs = {IPNetwork(iterable): True} elif isinstance(iterable, IPRange): self._cidrs = dict.fromkeys( iprange_to_cidrs(iterable[0], iterable[-1]), True) elif isinstance(iterable, IPSet): self._cidrs = dict.fromkeys(iterable.iter_cidrs(), True) else: self._cidrs = {} if iterable is not None: mergeable = [] for addr in iterable: if isinstance(addr, _int_type): addr = IPAddress(addr, flags=flags) mergeable.append(addr) for cidr in cidr_merge(mergeable): self._cidrs[cidr] = True
def __init__(self, base_cidr): """ Constructor. :param base_cidr: an IPv4 or IPv6 address with a CIDR prefix. (see IPNetwork.__init__ for full details). """ self._subnets = set([IPNetwork(base_cidr)])
def __setstate__(self, state): """ :param state: data used to unpickle a pickled ``IPSet`` object. """ self._cidrs = dict.fromkeys( (IPNetwork((value, prefixlen), version=version) for value, prefixlen, version in state), True)
def __contains__(self, ip): """ :param ip: An IP address or subnet. :return: ``True`` if IP address or subnet is a member of this IP set. """ ip = IPNetwork(ip) # Iterating over self._cidrs is an O(n) operation: 1000 items in # self._cidrs would mean 1000 loops. Iterating over all possible # supernets loops at most 32 times for IPv4 or 128 times for IPv6, # no matter how many CIDRs this object contains. if ip in self._cidrs: return True for cidr in ip.supernet(): if cidr in self._cidrs: return True return False
def test_choose_port_any(self): """Pick any port when they are all equally good.""" self.mech.networks = { 'host1': { 'port0': { 'zone1': (IPNetwork('101::/64'), 101, []) }, 'port1': { 'zone1': (IPNetwork('201::/64'), 201, []) }, 'port2': { 'zone1': (IPNetwork('301::/64'), 301, []) } } } self.mech.allocated_bandwidth = {} port = self.mech._choose_port('host1', 'zone1', 6, 5) self.assertIsNotNone(port, 'port0')
def _parseIPAddressPrefix(self, ipAddressPrefix): ipAddress = "" mask = 0 try: net = IPNetwork(ipAddressPrefix) (ipAddress, mask) = (str(net.ip), net.prefixlen) except netaddr.core.AddrFormatError as e: raise APIException("Bogus IP prefix: %s" % ipAddressPrefix) return (ipAddress, mask)
#!/usr/bin/python # need netaddr # sudo pip install netaddr import random from netaddr.ip import IPNetwork, IPAddress random.seed() ip_a = IPAddress('2001::cafe:0') + random.getrandbits(16) ip_n = IPNetwork(ip_a) ip_n.prefixlen = 64 print ip_a print ip_n