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 __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
