def _translate_ipv6_addr(ipv6_addrs):
return [
addr for addr in ipv6_addrs
if not netaddr.IPAddress(addr.split('/')[0]).is_link_local()]
def get_machines(self, machine_id=None, hostname=None, ip=None, any=None,
substring=False):
"""
Return matching machines.
:param machine_id: can be matched as substring
:param hostname: can be matched as substring
:param ip: can not be matched as substring
:param substring: Whether the filtering should be a substring matching
:type substring: bool
:param any: a substring that matches EITHER hostname, machineid or ip
:type any: basestring
:return: list of Machine Objects
"""
machines = []
f = open(self.filename, "r")
try:
for line in f:
split_line = line.split()
if len(split_line) < 2:
# skip lines with less than 2 columns
continue
if split_line[0][0] == "#":
# skip comments
continue
line_id = split_line[0]
line_ip = netaddr.IPAddress(split_line[0])
line_hostname = split_line[1:]
# check if machine_id, ip or hostname matches a substring
if (any and any not in line_id and
len([x for x in line_hostname if any in x]) <= 0 and
any not in "{0!s}".format(line_ip)):
# "any" was provided but did not match either
# hostname, ip or machine_id
continue
else:
if machine_id:
if not substring and machine_id == line_id:
return [Machine(self.name, line_id,
hostname=line_hostname, ip=line_ip)]
if substring and machine_id not in line_id:
# do not append this machine!
continue
if hostname:
if substring:
h_match = len([x for x in line_hostname if hostname in x])
else:
h_match = hostname in line_hostname
if not h_match:
# do not append this machine!
continue
if ip and ip != line_ip:
# Do not append this machine!
continue
machines.append(Machine(self.name, line_id,
hostname=line_hostname,
ip=line_ip))
finally:
f.close()
return machines
def is_in_subnet(self, subnet):
if self['address'] and subnet['cidr']:
return (netaddr.IPAddress(self['address'])
in netaddr.IPNetwork(subnet['cidr']))
else:
return False
def validate_local_address(ip_address):
if not valid_ip_address(ip_address):
raise ConfigValueError(desc='Invalid local ip_address: %s' %
ip_address)
return str(netaddr.IPAddress(ip_address))
def in_subnet(ip_str, subnet):
for net in subnet:
if netaddr.IPAddress(ip_str) in netaddr.IPNetwork(net):
return True
return False
def add_ipv6_prefix(self, prefix):
# having more than one prefix is not supported
self.ipv6_prefix = netaddr.IPAddress(prefix)
def deallocate_ips_by_port(self, context, port=None, **kwargs):
ips_to_remove = []
for addr in port["ip_addresses"]:
if "ip_address" in kwargs:
ip = kwargs["ip_address"]
if ip != netaddr.IPAddress(int(addr["address"])):
continue
# Note: only deallocate ip if this is the
# only port mapped
ips_to_remove.append(addr)
port["ip_addresses"] = list(
set(port["ip_addresses"]) - set(ips_to_remove))
# NCP-1541: We don't need to track v6 IPs the same way. Also, we can't
# delete them until we've removed the FK on the assoc record first, so
# we have to flush the current state of the transaction.
# NOTE(mdietz): this does increase traffic to the db because we need
# to flush, fetch the records again and potentially make
# another trip to deallocate each IP, but keeping our
# indices smaller probably provides more value than the
# cost
# NOTE(aquillin): For floating IPs associated with the port, we do not
# want to deallocate the IP or disassociate the IP from
# the tenant, instead we will disassociate floating's
# fixed IP address.
context.session.flush()
deallocated_ips = []
flip = None
for ip in ips_to_remove:
if ip["address_type"] in (ip_types.FLOATING, ip_types.SCALING):
flip = ip
else:
if len(ip["ports"]) == 0:
self.deallocate_ip_address(context, ip)
deallocated_ips.append(ip.id)
if flip:
if flip.fixed_ips and len(flip.fixed_ips) == 1:
# This is a FLIP or SCIP that is only associated with one
# port and fixed_ip, so we can safely just disassociate all
# and remove the flip from unicorn.
db_api.floating_ip_disassociate_all_fixed_ips(context, flip)
# NOTE(blogan): I'm not too happy about having do another
# flush but some test runs showed inconsistent state based on
# SQLAlchemy caching.
context.session.add(flip)
context.session.flush()
billing.notify(context, billing.IP_DISASSOC, flip, **kwargs)
driver = registry.DRIVER_REGISTRY.get_driver()
driver.remove_floating_ip(flip)
elif len(flip.fixed_ips) > 1:
# This is a SCIP and we need to diassociate the one fixed_ip
# from the SCIP and update unicorn with the remaining
# ports and fixed_ips
remaining_fixed_ips = []
for fix_ip in flip.fixed_ips:
if fix_ip.id in deallocated_ips:
db_api.floating_ip_disassociate_fixed_ip(
context, flip, fix_ip)
context.session.add(flip)
context.session.flush()
billing.notify(context, billing.IP_DISASSOC, flip,
**kwargs)
else:
remaining_fixed_ips.append(fix_ip)
port_fixed_ips = {}
for fix_ip in remaining_fixed_ips:
# NOTE(blogan): Since this is the flip's fixed_ips it
# should be safe to assume there is only one port
# associated with it.
remaining_port = fix_ip.ports[0]
port_fixed_ips[remaining_port.id] = {
'port': remaining_port,
'fixed_ip': fix_ip
}
driver = registry.DRIVER_REGISTRY.get_driver()
driver.update_floating_ip(flip, port_fixed_ips)
def constraint(obj, attr, value):
try:
return netaddr.IPAddress(value).__str__()
except netaddr.AddrFormatError as e:
raise ValueError(six.text_type(e))
def _allocate_from_v6_subnet(self, context, net_id, subnet,
port_id, reuse_after, ip_address=None,
**kwargs):
"""This attempts to allocate v6 addresses as per RFC2462 and RFC3041.
To accomodate this, we effectively treat all v6 assignment as a
first time allocation utilizing the MAC address of the VIF. Because
we recycle MACs, we will eventually attempt to recreate a previously
generated v6 address. Instead of failing, we've opted to handle
reallocating that address in this method.
This should provide a performance boost over attempting to check
each and every subnet in the existing reallocate logic, as we'd
have to iterate over each and every subnet returned
"""
LOG.info("Attempting to allocate a v6 address - [{0}]".format(
utils.pretty_kwargs(network_id=net_id, subnet=subnet,
port_id=port_id, ip_address=ip_address)))
if ip_address:
LOG.info("IP %s explicitly requested, deferring to standard "
"allocation" % ip_address)
return self._allocate_from_subnet(context, net_id=net_id,
subnet=subnet, port_id=port_id,
reuse_after=reuse_after,
ip_address=ip_address, **kwargs)
else:
mac = kwargs.get("mac_address")
if mac:
mac = kwargs["mac_address"].get("address")
if subnet and subnet["ip_policy"]:
ip_policy_cidrs = subnet["ip_policy"].get_cidrs_ip_set()
else:
ip_policy_cidrs = netaddr.IPSet([])
for tries, ip_address in enumerate(
generate_v6(mac, port_id, subnet["cidr"])):
LOG.info("Attempt {0} of {1}".format(
tries + 1, CONF.QUARK.v6_allocation_attempts))
if tries > CONF.QUARK.v6_allocation_attempts - 1:
LOG.info("Exceeded v6 allocation attempts, bailing")
raise ip_address_failure(net_id)
ip_address = netaddr.IPAddress(ip_address).ipv6()
LOG.info("Generated a new v6 address {0}".format(
str(ip_address)))
if (ip_policy_cidrs is not None and
ip_address in ip_policy_cidrs):
LOG.info("Address {0} excluded by policy".format(
str(ip_address)))
continue
try:
with context.session.begin():
address = db_api.ip_address_create(
context, address=ip_address,
subnet_id=subnet["id"],
version=subnet["ip_version"], network_id=net_id,
address_type=kwargs.get('address_type',
ip_types.FIXED))
return address
except db_exception.DBDuplicateEntry:
# This shouldn't ever happen, since we hold a unique MAC
# address from the previous IPAM step.
LOG.info("{0} exists but was already "
"allocated".format(str(ip_address)))
LOG.debug("Duplicate entry found when inserting subnet_id"
" %s ip_address %s", subnet["id"], ip_address)
def allocate_ip_address(self, context, new_addresses, net_id, port_id,
reuse_after, segment_id=None, version=None,
ip_addresses=None, subnets=None, **kwargs):
elevated = context.elevated()
subnets = subnets or []
ip_addresses = ip_addresses or []
ipam_log = kwargs.get('ipam_log', None)
LOG.info("Starting a new IP address(es) allocation. Strategy "
"is {0} - [{1}]".format(
self.get_name(),
utils.pretty_kwargs(network_id=net_id, port_id=port_id,
new_addresses=new_addresses,
ip_addresses=ip_addresses,
subnets=subnets,
segment_id=segment_id,
version=version)))
def _try_reallocate_ip_address(ipam_log, ip_addr=None):
new_addresses.extend(self.attempt_to_reallocate_ip(
context, net_id, port_id, reuse_after, version=version,
ip_address=ip_addr, segment_id=segment_id, subnets=subnets,
**kwargs))
def _try_allocate_ip_address(ipam_log, ip_addr=None, sub=None):
for retry in xrange(CONF.QUARK.ip_address_retry_max):
attempt = None
if ipam_log:
attempt = ipam_log.make_entry("_try_allocate_ip_address")
LOG.info("Allocating new IP attempt {0} of {1}".format(
retry + 1, CONF.QUARK.ip_address_retry_max))
if not sub:
subnets = self._choose_available_subnet(
elevated, net_id, version, segment_id=segment_id,
ip_address=ip_addr, reallocated_ips=new_addresses)
else:
subnets = [self.select_subnet(context, net_id,
ip_addr, segment_id,
subnet_ids=[sub])]
LOG.info("Subnet selection returned {0} viable subnet(s) - "
"IDs: {1}".format(len(subnets),
", ".join([str(s["id"])
for s in subnets if s])))
try:
self._allocate_ips_from_subnets(context, new_addresses,
net_id, subnets,
port_id, reuse_after,
ip_addr, **kwargs)
except q_exc.IPAddressRetryableFailure:
LOG.exception("Error in allocating IP")
if attempt:
LOG.debug("ATTEMPT FAILED")
attempt.failed()
remaining = CONF.QUARK.ip_address_retry_max - retry - 1
if remaining > 0:
LOG.info("{0} retries remain, retrying...".format(
remaining))
else:
LOG.info("No retries remaing, bailing")
continue
finally:
if attempt:
attempt.end()
break
ip_addresses = [netaddr.IPAddress(ip_address)
for ip_address in ip_addresses]
if ip_addresses:
for ip_address in ip_addresses:
_try_reallocate_ip_address(ipam_log, ip_address)
else:
_try_reallocate_ip_address(ipam_log)
if self.is_strategy_satisfied(new_addresses):
return
else:
LOG.info("Reallocated addresses {0} but still need more addresses "
"to satisfy strategy {1}. Falling back to creating "
"IPs".format(new_addresses, self.get_name()))
if ip_addresses or subnets:
for ip_address, subnet in itertools.izip_longest(ip_addresses,
subnets):
_try_allocate_ip_address(ipam_log, ip_address, subnet)
else:
_try_allocate_ip_address(ipam_log)
if self.is_strategy_satisfied(new_addresses, allocate_complete=True):
# Only notify when all went well
for address in new_addresses:
billing.notify(context, billing.IP_ADD, address, **kwargs)
LOG.info("IPAM for port ID {0} completed with addresses "
"{1}".format(port_id,
[a["address_readable"]
for a in new_addresses]))
return
ipam_log.failed()
raise ip_address_failure(net_id)
def cmdbprocess(scanrange, beintrusive, filename, project_id):
localipstring = getlocalinfo(project_id)
localip = str(localipstring).split("$")[0]
subnet = str(localipstring).split("$")[1]
interface = str(localipstring).split("$")[2]
print "processing " + str(len(localip)) + "local interfaces " + interface
cmdb_file_ips = []
gateway = netifaces.gateways()['default'][netifaces.AF_INET][0]
print "Gateway: " + gateway
gatewaynewnode = makeanode(gateway, subnet, project_id, 1, "CMDB", "",
True)
localnode = makeanode(localip, subnet, project_id, 0, "CMDB", "", True)
gatewaynewnode.connected.connect(localnode)
addaction(project_id, "CMDB", filename, gatewaynewnode)
addaction(project_id, "CMDB", filename, localnode)
for line in scanrange:
try:
ipaddress.ip_address(line)
cmdb_file_ips.append(line)
print "scanning IP " + line
scanresult = networkscan(line)
print "Scan results " + str(scanresult)
for ip in scanresult:
local_ip_range = localip + "/" + str(
netaddr.IPAddress(subnet).netmask_bits())
if netaddr.IPAddress(ip) in netaddr.IPNetwork(local_ip_range):
print "in local range"
node = makeanode(ip, subnet, project_id, 2, "CMDB", "",
True)
gatewaynewnode.connected.connect(node)
addaction(project_id, "CMDB", filename, node)
else:
print "performing traceroute to " + ip
output = traceroute.delay(ip, 33434, 30, project_id, True)
findseed = project_id + "#SEED"
seednode = Machine.nodes.get(tag__startswith=findseed)
addaction(
project_id, "GOTO", ip + "@" + str(output) + "@" +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M"),
seednode)
except Exception as ex:
print str(ex)
print "Not a valid IP. Ignoring " + line
if str(beintrusive) == "on":
local_ip_range = gateway + "/" + str(
netaddr.IPAddress(subnet).netmask_bits())
output = cmdbanalysis.delay(local_ip_range, cmdb_file_ips, project_id,
filename)
findseed = project_id + "#SEED"
seednode = Machine.nodes.get(tag__startswith=findseed)
addaction(
project_id, "CMDB",
str(local_ip_range) + "@" + str(output) + "@" +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M"), seednode)
output = traceroute.delay(
"google.com", 33434, 30, project_id,
True) # perform traceroute to (multiple?)google.com
seednode = Machine.nodes.get(tag__startswith=findseed)
addaction(
project_id, "GOTO", "google.com" + "@" + str(output) + "@" +
datetime.datetime.now().strftime("%Y-%m-%d %H:%M"), seednode)
return {"Status": True}
def is_eui64_address(ip_address):
"""Check if ip address is EUI64."""
ip = netaddr.IPAddress(ip_address)
# '0xfffe' addition is used to build EUI-64 from MAC (RFC4291)
# Look for it in the middle of the EUI-64 part of address
return ip.version == 6 and not ((ip & 0xffff000000) ^ 0xfffe000000)
def validate_next_hop(ip_address):
if not valid_ip_address(ip_address):
raise ConfigValueError(desc='Invalid next_hop ip_address: %s' %
ip_address)
return str(netaddr.IPAddress(ip_address))
def get_first_host_ip(net, ip_version):
return str(netaddr.IPAddress(net.first + 1, ip_version))
def tunnel_sync(self, rpc_context, **kwargs):
"""Update new tunnel.
Updates the database with the tunnel IP. All listening agents will also
be notified about the new tunnel IP.
"""
tunnel_ip = kwargs.get('tunnel_ip')
if not tunnel_ip:
msg = _("Tunnel IP value needed by the ML2 plugin")
raise exc.InvalidInput(error_message=msg)
host = kwargs.get('host')
version = netaddr.IPAddress(tunnel_ip).version
if version != cfg.CONF.ml2.overlay_ip_version:
msg = (_("Tunnel IP version does not match ML2 "
"overlay_ip_version: %(overlay)s, host: %(host)s, "
"tunnel_ip: %(ip)s"),
{'overlay': cfg.CONF.ml2.overlay_ip_version,
'host': host, 'ip': tunnel_ip})
raise exc.InvalidInput(error_message=msg)
tunnel_type = kwargs.get('tunnel_type')
if not tunnel_type:
msg = _("Network type value needed by the ML2 plugin")
raise exc.InvalidInput(error_message=msg)
driver = self._type_manager.drivers.get(tunnel_type)
if driver:
# The given conditional statements will verify the following
# things:
# 1. If host is not passed from an agent, it is a legacy mode.
# 2. If passed host and tunnel_ip are not found in the DB,
# it is a new endpoint.
# 3. If host is passed from an agent and it is not found in DB
# but the passed tunnel_ip is found, delete the endpoint
# from DB and add the endpoint with (tunnel_ip, host),
# it is an upgrade case.
# 4. If passed host is found in DB and passed tunnel ip is not
# found, delete the endpoint belonging to that host and
# add endpoint with latest (tunnel_ip, host), it is a case
# where local_ip of an agent got changed.
# 5. If the passed host had another ip in the DB the host-id has
# roamed to a different IP then delete any reference to the new
# local_ip or the host id. Don't notify tunnel_delete for the
# old IP since that one could have been taken by a different
# agent host-id (neutron-ovs-cleanup should be used to clean up
# the stale endpoints).
# Finally create a new endpoint for the (tunnel_ip, host).
if host:
host_endpoint = driver.obj.get_endpoint_by_host(host)
ip_endpoint = driver.obj.get_endpoint_by_ip(tunnel_ip)
if (ip_endpoint and ip_endpoint.host is None and
host_endpoint is None):
driver.obj.delete_endpoint(ip_endpoint.ip_address)
elif (ip_endpoint and ip_endpoint.host != host):
LOG.info(
"Tunnel IP %(ip)s was used by host %(host)s and "
"will be assigned to %(new_host)s",
{'ip': ip_endpoint.ip_address,
'host': ip_endpoint.host,
'new_host': host})
driver.obj.delete_endpoint_by_host_or_ip(
host, ip_endpoint.ip_address)
elif (host_endpoint and host_endpoint.ip_address != tunnel_ip):
# Notify all other listening agents to delete stale tunnels
self._notifier.tunnel_delete(
rpc_context, host_endpoint.ip_address, tunnel_type)
driver.obj.delete_endpoint(host_endpoint.ip_address)
tunnel = driver.obj.add_endpoint(tunnel_ip, host)
tunnels = driver.obj.get_endpoints()
entry = {'tunnels': tunnels}
# Notify all other listening agents
self._notifier.tunnel_update(rpc_context, tunnel.ip_address,
tunnel_type)
# Return the list of tunnels IP's to the agent
return entry
else:
msg = (_("Network type value %(type)s not supported, "
"host: %(host)s with tunnel IP: %(ip)s") %
{'type': tunnel_type,
'host': host or 'legacy mode (no host provided by agent)',
'ip': tunnel_ip})
raise exc.InvalidInput(error_message=msg)
def _validate_allocation_pools(self, ip_pools, subnet_cidr):
"""Validate IP allocation pools.
Verify start and end address for each allocation pool are valid,
ie: constituted by valid and appropriately ordered IP addresses.
Also, verify pools do not overlap among themselves.
Finally, verify that each range fall within the subnet's CIDR.
"""
subnet = netaddr.IPNetwork(subnet_cidr)
subnet_first_ip = netaddr.IPAddress(subnet.first + 1)
# last address is broadcast in v4
subnet_last_ip = netaddr.IPAddress(subnet.last - (subnet.version == 4))
LOG.debug("Performing IP validity checks on allocation pools")
ip_sets = []
for ip_pool in ip_pools:
try:
start_ip = netaddr.IPAddress(ip_pool['start'])
end_ip = netaddr.IPAddress(ip_pool['end'])
except netaddr.AddrFormatError:
LOG.info(_LI("Found invalid IP address in pool: "
"%(start)s - %(end)s:"),
{'start': ip_pool['start'],
'end': ip_pool['end']})
raise n_exc.InvalidAllocationPool(pool=ip_pool)
if (start_ip.version != subnet.version or
end_ip.version != subnet.version):
LOG.info(_LI("Specified IP addresses do not match "
"the subnet IP version"))
raise n_exc.InvalidAllocationPool(pool=ip_pool)
if end_ip < start_ip:
LOG.info(_LI("Start IP (%(start)s) is greater than end IP "
"(%(end)s)"),
{'start': ip_pool['start'], 'end': ip_pool['end']})
raise n_exc.InvalidAllocationPool(pool=ip_pool)
if start_ip < subnet_first_ip or end_ip > subnet_last_ip:
LOG.info(_LI("Found pool larger than subnet "
"CIDR:%(start)s - %(end)s"),
{'start': ip_pool['start'],
'end': ip_pool['end']})
raise n_exc.OutOfBoundsAllocationPool(
pool=ip_pool,
subnet_cidr=subnet_cidr)
# Valid allocation pool
# Create an IPSet for it for easily verifying overlaps
ip_sets.append(netaddr.IPSet(netaddr.IPRange(
ip_pool['start'],
ip_pool['end']).cidrs()))
LOG.debug("Checking for overlaps among allocation pools "
"and gateway ip")
ip_ranges = ip_pools[:]
# Use integer cursors as an efficient way for implementing
# comparison and avoiding comparing the same pair twice
for l_cursor in range(len(ip_sets)):
for r_cursor in range(l_cursor + 1, len(ip_sets)):
if ip_sets[l_cursor] & ip_sets[r_cursor]:
l_range = ip_ranges[l_cursor]
r_range = ip_ranges[r_cursor]
LOG.info(_LI("Found overlapping ranges: %(l_range)s and "
"%(r_range)s"),
{'l_range': l_range, 'r_range': r_range})
raise n_exc.OverlappingAllocationPools(
pool_1=l_range,
pool_2=r_range,
subnet_cidr=subnet_cidr)
def _translate_vip_object_graph(extended_vip, plugin, context):
"""Translate the extended vip
translate to a structure that can be
understood by the workflow.
"""
def _create_key(prefix, property_name):
return prefix + '_' + property_name + '_array'
def _trans_prop_name(prop_name):
if prop_name == 'id':
return 'uuid'
else:
return prop_name
def get_ids(extended_vip):
ids = {}
ids['vip'] = extended_vip['id']
ids['pool'] = extended_vip['pool']['id']
ids['members'] = [m['id'] for m in extended_vip['members']]
ids['health_monitors'] = [
hm['id'] for hm in extended_vip['health_monitors']
]
return ids
trans_vip = {}
LOG.debug('Vip graph to be translated: ' + str(extended_vip))
for vip_property in VIP_PROPERTIES:
trans_vip['vip_' + vip_property] = extended_vip.get(
vip_property, TRANSLATION_DEFAULTS.get(vip_property))
for pool_property in POOL_PROPERTIES:
trans_vip['pool_' +
pool_property] = extended_vip['pool'][pool_property]
for member_property in MEMBER_PROPERTIES:
trans_vip[_create_key('member', member_property)] = []
two_leg = (extended_vip['pip_address'] != extended_vip['address'])
if two_leg:
pool_subnet = plugin._core_plugin.get_subnet(
context, extended_vip['pool']['subnet_id'])
for member in extended_vip['members']:
if member['status'] != constants.PENDING_DELETE:
if (two_leg and netaddr.IPAddress(member['address'])
not in netaddr.IPNetwork(pool_subnet['cidr'])):
member_ports = plugin._core_plugin.get_ports(
context,
filters={
'fixed_ips': {
'ip_address': [member['address']]
},
'tenant_id': [extended_vip['tenant_id']]
})
if len(member_ports) == 1:
member_subnet = plugin._core_plugin.get_subnet(
context, member_ports[0]['fixed_ips'][0]['subnet_id'])
member_network = netaddr.IPNetwork(member_subnet['cidr'])
member['subnet'] = str(member_network.network)
member['mask'] = str(member_network.netmask)
else:
member['subnet'] = member['address']
member['gw'] = pool_subnet['gateway_ip']
for member_property in MEMBER_PROPERTIES:
trans_vip[_create_key('member', member_property)].append(
member.get(member_property,
TRANSLATION_DEFAULTS.get(member_property)))
for hm_property in HEALTH_MONITOR_PROPERTIES:
trans_vip[_create_key('hm', _trans_prop_name(hm_property))] = []
for hm in extended_vip['health_monitors']:
hm_pool = plugin.get_pool_health_monitor(context, hm['id'],
extended_vip['pool']['id'])
if hm_pool['status'] != constants.PENDING_DELETE:
for hm_property in HEALTH_MONITOR_PROPERTIES:
value = hm.get(hm_property,
TRANSLATION_DEFAULTS.get(hm_property))
trans_vip[_create_key(
'hm', _trans_prop_name(hm_property))].append(value)
ids = get_ids(extended_vip)
trans_vip['__ids__'] = ids
if 'pip_address' in extended_vip:
trans_vip['pip_address'] = extended_vip['pip_address']
LOG.debug('Translated Vip graph: ' + str(trans_vip))
return trans_vip
LAST_EXTERNAL_IP = stun_ip
LAST_EXTERNAL_IP_TIME = time.time()
return LAST_EXTERNAL_IP
except Exception, e:
logger.debug('external_ip: STUN failed: %s', e)
ctx = tinyhttp.HTTP(timeout=5, headers={'User-Agent': 'curl/7.12.3'})
for service in OWN_IP:
for scheme in ['https', 'http']:
try:
data, code = ctx.get(scheme + '://' + service, code=True)
if code == 200:
addr = netaddr.IPAddress(data.strip())
if force_ipv4 and addr.version == 6:
continue
LAST_EXTERNAL_IP = addr
LAST_EXTERNAL_IP_TIME = time.time()
return LAST_EXTERNAL_IP
except Exception, e:
logger.debug('Get IP service failed: %s: %s (%s)', service, e,
type(e))
LAST_EXTERNAL_IP = dns_external_ip()
if LAST_EXTERNAL_IP:
LAST_EXTERNAL_IP_TIME = time.time()
def _verify_port_dns(self,
net,
port,
dns_data_db,
dns_name=True,
dns_domain=True,
ptr_zones=True,
delete_records=False,
provider_net=True,
dns_driver=True,
original_ips=None,
current_dns_name=DNSNAME,
previous_dns_name=''):
if dns_name:
self.assertEqual(current_dns_name, port[dns.DNSNAME])
if dns_name and dns_domain and provider_net and dns_driver:
self.assertEqual(current_dns_name, dns_data_db['current_dns_name'])
self.assertEqual(previous_dns_name,
dns_data_db['previous_dns_name'])
if current_dns_name:
self.assertEqual(net[dns.DNSDOMAIN],
dns_data_db['current_dns_domain'])
else:
self.assertFalse(dns_data_db['current_dns_domain'])
records_v4 = [
ip['ip_address'] for ip in port['fixed_ips']
if netaddr.IPAddress(ip['ip_address']).version == 4
]
records_v6 = [
ip['ip_address'] for ip in port['fixed_ips']
if netaddr.IPAddress(ip['ip_address']).version == 6
]
expected = []
expected_delete = []
if records_v4:
if current_dns_name:
expected.append(
mock.call(net[dns.DNSDOMAIN], current_dns_name, 'A',
records_v4))
if delete_records:
expected_delete.append(
mock.call(net[dns.DNSDOMAIN], V4UUID))
if records_v6:
if current_dns_name:
expected.append(
mock.call(net[dns.DNSDOMAIN], current_dns_name, 'AAAA',
records_v6))
if delete_records:
expected_delete.append(
mock.call(net[dns.DNSDOMAIN], V6UUID))
mock_client.recordsets.create.assert_has_calls(expected,
any_order=True)
self.assertEqual(len(mock_client.recordsets.create.call_args_list),
len(expected))
mock_client.recordsets.delete.assert_has_calls(expected_delete,
any_order=True)
self.assertEqual(len(mock_client.recordsets.delete.call_args_list),
len(expected_delete))
expected = []
expected_delete = []
if ptr_zones:
records = records_v4 + records_v6
recordset_name = '%s.%s' % (current_dns_name,
net[dns.DNSDOMAIN])
for record in records:
in_addr_name = netaddr.IPAddress(record).reverse_dns
in_addr_zone_name = self._get_in_addr_zone_name(
in_addr_name)
if current_dns_name:
expected.append(
mock.call(in_addr_zone_name, in_addr_name, 'PTR',
[recordset_name]))
if delete_records and not original_ips:
expected_delete.append(
mock.call(in_addr_zone_name, in_addr_name))
if delete_records and original_ips:
for record in original_ips:
in_addr_name = netaddr.IPAddress(record).reverse_dns
in_addr_zone_name = self._get_in_addr_zone_name(
in_addr_name)
expected_delete.append(
mock.call(in_addr_zone_name, in_addr_name))
mock_admin_client.recordsets.create.assert_has_calls(
expected, any_order=True)
self.assertEqual(
len(mock_admin_client.recordsets.create.call_args_list),
len(expected))
mock_admin_client.recordsets.delete.assert_has_calls(
expected_delete, any_order=True)
self.assertEqual(
len(mock_admin_client.recordsets.delete.call_args_list),
len(expected_delete))
else:
if not dns_name:
self.assertEqual('', port[dns.DNSNAME])
self.assertIsNone(dns_data_db)
self.assertFalse(mock_client.recordsets.create.call_args_list)
self.assertFalse(
mock_admin_client.recordsets.create.call_args_list)
self.assertFalse(mock_client.recordsets.delete.call_args_list)
self.assertFalse(
mock_admin_client.recordsets.delete.call_args_list)
def is_my_ipv6_addr(self, ipv6_addr):
# get a address string in the canonical format
target_ipv6_addr = str(netaddr.IPAddress(ipv6_addr))
return ((self.get_ipv6_global_addr() == target_ipv6_addr)
or (self.get_ipv6_link_local_addr() == target_ipv6_addr))
vcpus=4,
memory_mb=10 * 1024,
local_gb=250,
vcpus_used=2,
memory_mb_used=5 * 1024,
local_gb_used=125,
hypervisor_type="xen",
hypervisor_version=3,
hypervisor_hostname="hyper1",
free_ram_mb=5 * 1024,
free_disk_gb=125,
current_workload=2,
running_vms=2,
cpu_info='cpu_info',
disk_available_least=100,
host_ip=netaddr.IPAddress('1.1.1.1')),
dict(id=2,
service_id=2,
host="compute2",
vcpus=4,
memory_mb=10 * 1024,
local_gb=250,
vcpus_used=2,
memory_mb_used=5 * 1024,
local_gb_used=125,
hypervisor_type="xen",
hypervisor_version=3,
hypervisor_hostname="hyper2",
free_ram_mb=5 * 1024,
free_disk_gb=125,
current_workload=2,
def coerce(obj, attr, value):
try:
return netaddr.IPAddress(value)
except netaddr.AddrFormatError as e:
raise ValueError(str(e))
def process_result_value(self, value, dialect):
return netaddr.IPAddress(value)
def configure_traffic_stream(self, traffic_flows, nr_of_flows,
packet_size, **kwargs):
flow_percentage = kwargs.pop("percentage", 1000000) / 10000
trex_dst_mac = kwargs.pop("traffic_dst_mac", '00:00:02:00:00:00')
trex_src_mac = kwargs.pop("traffic_src_mac", '00:00:01:00:00:00')
l2_macs = kwargs.pop("l2_macs", 1)
#
# The packet size passed here assumes it includes the checksum, however
# the TRex packet size does not. Adjust the size to correct this.
#
packet_size -= 4
if traffic_flows == TrafficFlowType.none or \
self.__traffic_flows != TrafficFlowType.none:
#
# We need either a cleanup, or a cleanup before we configure
# a new traffic flow type
#
self._delete_traffic_stream_config()
if traffic_flows == TrafficFlowType.l2_mac or \
traffic_flows == TrafficFlowType.l3_ipv4 or \
traffic_flows == TrafficFlowType.nfv_mobile:
#
# Max flows due to IPv4 address limit, and addresses used for tests
#
if nr_of_flows > 0x00ffffff:
raise ValueError("To many flows requested, max {} supported!".
format(0x00ffffff))
L2 = Ether(src=trex_src_mac,
dst=trex_dst_mac)
L3 = IP(src="1.0.0.0",
dst="2.0.0.0")
L4 = UDP(chksum=0)
if (len(str(L2/L3/L4)) + 4) > packet_size: # +4 for Ethernet CRC
raise ValueError("Packet size ({} bytes) to small for"
"requested packet ({} bytes)!".
format(packet_size, len(L2/L3/L4) + 4))
if traffic_flows == TrafficFlowType.l2_mac:
src_base = self._mac_2_int(trex_src_mac) & 0xff000000
dst_base = self._mac_2_int(trex_dst_mac) & 0xff000000
vm = [
# Source MAC address
STLVmFlowVar(name="src",
min_value=src_base,
max_value=src_base + nr_of_flows - 1,
size=4, op="inc"),
STLVmWrFlowVar(fv_name="src", pkt_offset=8),
# Destination MAC address
STLVmFlowVar(name="dst",
min_value=dst_base,
max_value=dst_base + nr_of_flows - 1,
size=4, op="inc"),
STLVmWrFlowVar(fv_name="dst", pkt_offset=2)
]
elif traffic_flows == TrafficFlowType.l3_ipv4:
src_end = str(netaddr.IPAddress(
int(netaddr.IPAddress('1.0.0.0')) +
nr_of_flows - 1))
dst_end = str(netaddr.IPAddress(
int(netaddr.IPAddress('2.0.0.0')) +
nr_of_flows - 1))
vm = [
# Source IPv4 address
STLVmFlowVar(name="src", min_value="1.0.0.0",
max_value=src_end, size=4, op="inc"),
STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
# Destination IPv4 address
STLVmFlowVar(name="dst", min_value="2.0.0.0",
max_value=dst_end, size=4, op="inc"),
STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
# Checksum
STLVmFixIpv4(offset="IP")
]
elif traffic_flows == TrafficFlowType.nfv_mobile:
src_end = str(netaddr.IPAddress(
int(netaddr.IPAddress('1.0.0.0')) +
nr_of_flows - 1))
dst_end = str(netaddr.IPAddress(
int(netaddr.IPAddress('2.0.0.0')) +
nr_of_flows - 1))
vm = [
# Source MAC address
STLVmFlowVar(name="srcm",
min_value=0x01000001,
max_value=0x01000001 + l2_macs - 1,
size=4, op="inc"),
STLVmWrFlowVar(fv_name="srcm", pkt_offset=8),
# Destination MAC address
STLVmFlowVar(name="dstm",
min_value=0x02000000,
max_value=0x02000000 + l2_macs - 1,
size=4, op="inc"),
STLVmWrFlowVar(fv_name="dstm", pkt_offset=2),
# Source IPv4 address
STLVmFlowVar(name="src", min_value="1.0.0.0",
max_value=src_end, size=4, op="inc"),
STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
# Destination IPv4 address
STLVmFlowVar(name="dst", min_value="2.0.0.0",
max_value=dst_end, size=4, op="inc"),
STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
# Checksum
STLVmFixIpv4(offset="IP")
]
else:
raise ValueError("Unsupported traffic type for T-Rex tester!!!")
if traffic_flows == TrafficFlowType.nfv_mobile:
stream_percentage = flow_percentage / 2
else:
stream_percentage = flow_percentage
headers = L2/L3/L4
padding = max(0, (packet_size - len(headers))) * 'e'
packet = headers/padding
trex_packet = STLPktBuilder(pkt=packet, vm=vm)
trex_stream = STLStream(packet=trex_packet,
mode=STLTXCont(percentage=stream_percentage))
self.__trex_client.add_streams(trex_stream,
ports=[self.__trex_port])
#
# For nfv_mobile we still need to setup the alternating streams.
#
if traffic_flows == TrafficFlowType.nfv_mobile:
alternate_flows = kwargs.pop("alternate_flows", 200000)
stream_percentage = flow_percentage / 2
self.__active_alternate_stream = 0
#
# Keep the flows the same as for the Xena version, so the
# traffic scripts using this do not have to differentiate
# between traffic generator types.
#
# The Xena uses streams and every stream can generate 64K
# flows. To Find the flow start we need the number of base
# flows rounded of the next 64K (stream) and use the next one.
#
# For the individual iterations of the flow set they also
# need to start at a 64K boundary.
#
start_stream_id = self._div_round_up(nr_of_flows, 0x10000) + 1
for alternate_flow_sets in range(0, 3):
flow_start = start_stream_id * 0x10000
src_start = str(netaddr.IPAddress(
int(netaddr.IPAddress('1.0.0.0')) +
flow_start))
src_end = str(netaddr.IPAddress(
int(netaddr.IPAddress('1.0.0.0')) +
flow_start +
alternate_flows - 1))
dst_start = str(netaddr.IPAddress(
int(netaddr.IPAddress('2.0.0.0')) +
flow_start))
dst_end = str(netaddr.IPAddress(
int(netaddr.IPAddress('2.0.0.0')) +
flow_start +
alternate_flows - 1))
vm = [
# Source MAC address
STLVmFlowVar(name="srcm",
min_value=0x01000001,
max_value=0x01000001 + l2_macs - 1,
size=4, op="inc"),
STLVmWrFlowVar(fv_name="srcm", pkt_offset=8),
# Destination MAC address
STLVmFlowVar(name="dstm",
min_value=0x02000000,
max_value=0x02000000 + l2_macs - 1,
size=4, op="inc"),
STLVmWrFlowVar(fv_name="dstm", pkt_offset=2),
# Source IPv4 address
STLVmFlowVar(name="src", min_value=src_start,
max_value=src_end, size=4, op="inc"),
STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
# Destination IPv4 address
STLVmFlowVar(name="dst", min_value=dst_start,
max_value=dst_end, size=4, op="inc"),
STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
# Checksum
STLVmFixIpv4(offset="IP")
]
trex_packet = STLPktBuilder(pkt=packet, vm=vm)
stream = STLStream(packet=trex_packet,
mode=STLTXCont(percentage=stream_percentage),
start_paused=False
if alternate_flow_sets == 0 else True)
self.__alternate_stream_sets.append(
self.__trex_client.add_streams(stream,
ports=[self.__trex_port]))
start_stream_id += self._div_round_up(alternate_flows, 0x10000)
self.__traffic_flows = traffic_flows
return True
elif traffic_flows == TrafficFlowType.none:
self.__traffic_flows = traffic_flows
return True
else:
raise ValueError("Unsupported traffic flow passed for T-Rex tester!")
self.__traffic_flows = TrafficFlowType.none
return False
t = time.time()
while True:
try:
if time.time() - t > 5:
t = time.time()
try:
cursor = conn.cursor()
try:
with open('leasesmanual.leases') as f:
leasesContent = f.read().splitlines()
for content in leasesContent:
content = content.split(' ')
try:
cursor.execute(
"insert into leases (id, leaseTime, ip, host, mac, leaseStatus) values ('{0}', now(), '{1}', '{2}', '{3}', 'd') ON DUPLICATE KEY UPDATE leaseTime = now(), ip = '{1}', leaseStatus = 'd'"
.format(content[4],
int(netaddr.IPAddress(content[2])),
content[3], content[1]))
conn.commit()
except:
print 'error inserting MySQL row'
except:
print 'error deleting table leases'
except:
print 'cannot open cursor to MySQL database...'
except KeyboardInterrupt:
conn.close()
break
sys.exit()
