def test_nova_to_osvif_ips(self):
ips = [
model.FixedIP(address="192.168.122.24",
floating_ips=[
model.IP(address="192.168.122.100",
type="floating"),
model.IP(address="192.168.122.101",
type="floating"),
model.IP(address="192.168.122.102",
type="floating"),
],
version=4),
model.FixedIP(address="2001::beef", version=6),
]
actual = os_vif_util._nova_to_osvif_ips(ips)
expect = osv_objects.fixed_ip.FixedIPList(objects=[
osv_objects.fixed_ip.FixedIP(address="192.168.122.24",
floating_ips=[
"192.168.122.100",
"192.168.122.101",
"192.168.122.102",
]),
osv_objects.fixed_ip.FixedIP(address="2001::beef",
floating_ips=[]),
], )
self.assertObjEqual(expect, actual)
def new_fixed_ip(ip_dict=None, version=4):
if version == 6:
new_fixed_ip = dict(address='fd00::1:100', version=6)
elif version == 4:
new_fixed_ip = dict(address='192.168.1.100')
ip_dict = ip_dict or {}
new_fixed_ip.update(ip_dict)
return model.FixedIP(**new_fixed_ip)
def _nw_info_get_ips(self, client, port):
network_IPs = []
for fixed_ip in port['fixed_ips']:
fixed = network_model.FixedIP(address=fixed_ip['ip_address'])
floats = self._get_floating_ips_by_fixed_and_port(
client, fixed_ip['ip_address'], port['id'])
for ip in floats:
fip = network_model.IP(address=ip['floating_ip_address'],
type='floating')
fixed.add_floating_ip(fip)
network_IPs.append(fixed)
return network_IPs
def _mgmt_cna_to_vif(self, cna):
"""Converts the mgmt CNA to VIF format for network injection."""
mac = vm.norm_mac(cna.mac)
ipv6_link_local = self._mac_to_link_local(mac)
subnet = network_model.Subnet(
version=6, cidr=_LLA_SUBNET,
ips=[network_model.FixedIP(address=ipv6_link_local)])
network = network_model.Network(id='mgmt', subnets=[subnet],
injected='yes')
return network_model.VIF(id='mgmt_vif', address=mac,
network=network)
def _build_network_info_model(self, context, instance, networks=None):
search_opts = {
'tenant_id': instance['project_id'],
'device_id': instance['uuid'],
}
data = quantumv2.get_client(context,
admin=True).list_ports(**search_opts)
ports = data.get('ports', [])
if not networks:
networks = self._get_available_networks(context,
instance['project_id'])
else:
# ensure ports are in preferred network order
_ensure_requested_network_ordering(lambda x: x['network_id'],
ports,
[n['id'] for n in networks])
nw_info = network_model.NetworkInfo()
for port in ports:
network_name = None
for net in networks:
if port['network_id'] == net['id']:
network_name = net['name']
break
network_IPs = [
network_model.FixedIP(address=ip_address) for ip_address in
[ip['ip_address'] for ip in port['fixed_ips']]
]
# TODO(gongysh) get floating_ips for each fixed_ip
subnets = self._get_subnets_from_port(context, port)
for subnet in subnets:
subnet['ips'] = [
fixed_ip for fixed_ip in network_IPs
if fixed_ip.is_in_subnet(subnet)
]
network = network_model.Network(
id=port['network_id'],
bridge='', # Quantum ignores this field
injected=CONF.flat_injected,
label=network_name,
tenant_id=net['tenant_id'])
network['subnets'] = subnets
nw_info.append(
network_model.VIF(id=port['id'],
address=port['mac_address'],
network=network,
type=port.get('binding:vif_type')))
return nw_info
def test_equate_two_dissimilar_fixed_ips_fails(self):
fixed_ip = model.FixedIP(address='::1')
fixed_ip2 = model.FixedIP(address='::2')
self.assertNotEqual(fixed_ip, fixed_ip2)
fixed_ip = model.FixedIP(address='::1', type='1')
fixed_ip2 = model.FixedIP(address='::1', type='2')
self.assertNotEqual(fixed_ip, fixed_ip2)
fixed_ip = model.FixedIP(address='::1', version='6')
fixed_ip2 = model.FixedIP(address='::1', version='4')
self.assertNotEqual(fixed_ip, fixed_ip2)
fixed_ip = model.FixedIP(address='::1', floating_ips='1.1.1.1')
fixed_ip2 = model.FixedIP(address='::1', floating_ips='8.8.8.8')
self.assertNotEqual(fixed_ip, fixed_ip2)
def _build_network_info_model(self, context, instance, networks=None):
search_opts = {
'tenant_id': instance['project_id'],
'device_id': instance['uuid'],
}
data = quantumv2.get_client(context).list_ports(**search_opts)
ports = data.get('ports', [])
if not networks:
search_opts = {}
if instance['project_id']:
search_opts.update({"tenant_id": instance['project_id']})
data = quantumv2.get_client(context).list_networks(**search_opts)
networks = data.get('networks', [])
nw_info = network_model.NetworkInfo()
for port in ports:
network_name = None
for net in networks:
if port['network_id'] == net['id']:
network_name = net['name']
break
subnets = self._get_subnets_from_port(context, port)
network_IPs = [
network_model.FixedIP(address=ip_address) for ip_address in
[ip['ip_address'] for ip in port['fixed_ips']]
]
# TODO(gongysh) get floating_ips for each fixed_ip
for subnet in subnets:
subnet['ips'] = [
fixed_ip for fixed_ip in network_IPs
if fixed_ip.is_in_subnet(subnet)
]
network = network_model.Network(
id=port['network_id'],
bridge='', # Quantum ignores this field
injected=FLAGS.flat_injected,
label=network_name,
tenant_id=net['tenant_id'])
network['subnets'] = subnets
nw_info.append(
network_model.VIF(id=port['id'],
address=port['mac_address'],
network=network))
return nw_info
def test_equate_two_fixed_ips(self):
fixed_ip = model.FixedIP(address='::1')
fixed_ip2 = model.FixedIP(address='::1')
self.assertEqual(fixed_ip, fixed_ip2)
def _build_network_info_model(self, context, instance, networks=None):
"""This is a slightly different version than the super.
Adds support to relax the filters for the service tenant.
Workaround the fact that nova doesn't like ipv6 subnet only
"""
search_opts = {'device_id': instance['uuid']}
# NOTE(rods): The following "if" statement is not present in the
# parent method.
if context.project_name != 'service' or context.user_name != 'neutron':
search_opts['tenant_id'] = instance['project_id']
client = neutronv2.get_client(context, admin=True)
data = client.list_ports(**search_opts)
ports = data.get('ports', [])
if networks is None:
# retrieve networks from info_cache to get correct nic order
network_cache = self.conductor_api.instance_get_by_uuid(
context, instance['uuid'])['info_cache']['network_info']
network_cache = jsonutils.loads(network_cache)
net_ids = [iface['network']['id'] for iface in network_cache]
networks = self._get_available_networks(context,
instance['project_id'],
net_ids) # akanda change
# ensure ports are in preferred network order, and filter out
# those not attached to one of the provided list of networks
else:
net_ids = [n['id'] for n in networks]
ports = [port for port in ports if port['network_id'] in net_ids]
api._ensure_requested_network_ordering(lambda x: x['network_id'],
ports, net_ids)
nw_info = network_model.NetworkInfo()
for port in ports:
network_IPs = self._nw_info_get_ips(client, port)
subnets = self._nw_info_get_subnets(context, port, network_IPs)
# Nova does not like only IPv6, so let's lie and add a fake
# link-local IPv4. Neutron provides DHCP so this is ignored.
# NOTE(rods): This workaround is not present in the parent method
if not any(ip['version'] == 4 for ip in network_IPs):
nova_lie = {
'cidr': '169.254.0.0/16',
'gateway': network_model.IP(address='', type='gateway'),
'ips': [network_model.FixedIP(address='169.254.10.20')]
}
subnets.append(nova_lie)
devname = "tap" + port['id']
devname = devname[:network_model.NIC_NAME_LEN]
network, ovs_interfaceid = self._nw_info_build_network(
port, networks, subnets)
nw_info.append(
network_model.VIF(id=port['id'],
address=port['mac_address'],
network=network,
type=port.get('binding:vif_type'),
ovs_interfaceid=ovs_interfaceid,
devname=devname))
return nw_info
def fake_get_instance_nw_info(test, num_networks=1):
def update_cache_fake(*args, **kwargs):
fake_info_cache = {
'created_at': None,
'updated_at': None,
'deleted_at': None,
'deleted': False,
'instance_uuid': uuids.vifs_1,
'network_info': '[]',
}
return fake_info_cache
test.stub_out('nova.db.api.instance_info_cache_update', update_cache_fake)
# TODO(stephenfin): This doesn't match the kind of object we would receive
# from '_build_vif_model' and callers of same. We should fix that.
nw_model = network_model.NetworkInfo()
for network_id in range(1, num_networks + 1):
network = network_model.Network(
id=getattr(uuids, 'network%i' % network_id),
bridge='fake_br%d' % network_id,
label='test%d' % network_id,
subnets=[
network_model.Subnet(
cidr='192.168.%d.0/24' % network_id,
dns=[
network_model.IP(
address='192.168.%d.3' % network_id,
type='dns',
version=4,
meta={},
),
network_model.IP(
address='192.168.%d.4' % network_id,
type='dns',
version=4,
meta={},
),
],
gateway=network_model.IP(
address='192.168.%d.1' % network_id,
type='gateway',
version=4,
meta={},
),
ips=[
network_model.FixedIP(
address='192.168.%d.100' % network_id,
version=4,
meta={},
),
],
routes=[],
version=4,
meta={},
),
network_model.Subnet(
cidr='2001:db8:0:%x::/64' % network_id,
dns=[],
gateway=network_model.IP(
address='2001:db8:0:%x::1' % network_id,
type='gateway',
version=6,
meta={},
),
ips=[
network_model.FixedIP(
address='2001:db8:0:%x:dcad:beff:feef:1' %
(network_id),
version=6,
meta={},
),
],
routes=[],
version=6,
meta={}),
],
meta={"tenant_id": "806e1f03-b36f-4fc6-be29-11a366f150eb"},
)
vif = network_model.VIF(
id=getattr(uuids, 'vif%i' % network_id),
address='DE:AD:BE:EF:00:%02x' % network_id,
network=network,
type='bridge',
details={},
devname=None,
ovs_interfaceid=None,
qbh_params=None,
qbg_params=None,
active=False,
vnic_type='normal',
profile={},
preserve_on_delete=False,
meta={'rxtx_cap': 30},
)
nw_model.append(vif)
return nw_model
def test_create_fixed_ipv6(self):
fixed_ip = model.FixedIP(address='::1')
self.assertEqual('::1', fixed_ip['address'])
self.assertEqual([], fixed_ip['floating_ips'])
self.assertEqual('fixed', fixed_ip['type'])
self.assertEqual(6, fixed_ip['version'])
def new_ip(ip_dict=None):
new_ip = dict(address='192.168.1.100')
ip_dict = ip_dict or {}
new_ip.update(ip_dict)
return model.FixedIP(**new_ip)
def test_add_floating_ip_repeatedly_only_one_instance(self):
fixed_ip = model.FixedIP(address='192.168.1.100')
for i in range(10):
fixed_ip.add_floating_ip('192.168.1.101')
self.assertEqual(['192.168.1.101'], fixed_ip['floating_ips'])
def test_createnew_fixed_ip_with_attrs(self):
fixed_ip = model.FixedIP(address='192.168.1.100')
self.assertEqual('192.168.1.100', fixed_ip['address'])
self.assertEqual([], fixed_ip['floating_ips'])
self.assertEqual('fixed', fixed_ip['type'])
self.assertEqual(4, fixed_ip['version'])
def test_add_floating_ip(self):
fixed_ip = model.FixedIP(address='192.168.1.100')
fixed_ip.add_floating_ip('192.168.1.101')
self.assertEqual(['192.168.1.101'], fixed_ip['floating_ips'])
def test_nova_to_osvif_subnets(self):
subnets = [
model.Subnet(cidr="192.168.1.0/24",
dns=[
model.IP(
address="192.168.1.1",
type="dns"),
model.IP(
address="192.168.1.2",
type="dns"),
],
gateway=model.IP(
address="192.168.1.254",
type='gateway'),
ips=[
model.FixedIP(
address="192.168.1.100",
),
model.FixedIP(
address="192.168.1.101",
),
],
routes=[
model.Route(
cidr="10.0.0.1/24",
gateway=model.IP(
address="192.168.1.254",
type="gateway"),
interface="eth0"),
]),
model.Subnet(dns=[
model.IP(
address="192.168.1.1",
type="dns"),
model.IP(
address="192.168.1.2",
type="dns"),
],
ips=[
model.FixedIP(
address="192.168.1.100",
),
model.FixedIP(
address="192.168.1.101",
),
],
routes=[
model.Route(
cidr="10.0.0.1/24",
gateway=model.IP(
address="192.168.1.254",
type="gateway"),
interface="eth0"),
]),
model.Subnet(dns=[
model.IP(
address="192.168.1.1",
type="dns"),
model.IP(
address="192.168.1.2",
type="dns"),
],
gateway=model.IP(
type='gateway'),
ips=[
model.FixedIP(
address="192.168.1.100",
),
model.FixedIP(
address="192.168.1.101",
),
],
routes=[
model.Route(
cidr="10.0.0.1/24",
gateway=model.IP(
address="192.168.1.254",
type="gateway"),
interface="eth0"),
]),
]
expect = osv_objects.subnet.SubnetList(
objects=[
osv_objects.subnet.Subnet(
cidr="192.168.1.0/24",
dns=["192.168.1.1",
"192.168.1.2"],
gateway="192.168.1.254",
ips=osv_objects.fixed_ip.FixedIPList(
objects=[
osv_objects.fixed_ip.FixedIP(
address="192.168.1.100",
floating_ips=[]),
osv_objects.fixed_ip.FixedIP(
address="192.168.1.101",
floating_ips=[]),
]),
routes=osv_objects.route.RouteList(
objects=[
osv_objects.route.Route(
cidr="10.0.0.1/24",
gateway="192.168.1.254",
interface="eth0")
]),
),
osv_objects.subnet.Subnet(
dns=["192.168.1.1",
"192.168.1.2"],
ips=osv_objects.fixed_ip.FixedIPList(
objects=[
osv_objects.fixed_ip.FixedIP(
address="192.168.1.100",
floating_ips=[]),
osv_objects.fixed_ip.FixedIP(
address="192.168.1.101",
floating_ips=[]),
]),
routes=osv_objects.route.RouteList(
objects=[
osv_objects.route.Route(
cidr="10.0.0.1/24",
gateway="192.168.1.254",
interface="eth0")
]),
),
osv_objects.subnet.Subnet(
dns=["192.168.1.1",
"192.168.1.2"],
ips=osv_objects.fixed_ip.FixedIPList(
objects=[
osv_objects.fixed_ip.FixedIP(
address="192.168.1.100",
floating_ips=[]),
osv_objects.fixed_ip.FixedIP(
address="192.168.1.101",
floating_ips=[]),
]),
routes=osv_objects.route.RouteList(
objects=[
osv_objects.route.Route(
cidr="10.0.0.1/24",
gateway="192.168.1.254",
interface="eth0")
]),
),
])
actual = os_vif_util._nova_to_osvif_subnets(subnets)
self.assertObjEqual(expect, actual)
def _build_network_info_model(self, context, instance, networks=None):
search_opts = {
'tenant_id': instance['project_id'],
'device_id': instance['uuid'],
}
client = quantumv2.get_client(context, admin=True)
data = client.list_ports(**search_opts)
ports = data.get('ports', [])
if networks is None:
networks = self._get_available_networks(context,
instance['project_id'])
# ensure ports are in preferred network order, and filter out
# those not attached to one of the provided list of networks
net_ids = [n['id'] for n in networks]
ports = [port for port in ports if port['network_id'] in net_ids]
_ensure_requested_network_ordering(lambda x: x['network_id'], ports,
net_ids)
nw_info = network_model.NetworkInfo()
for port in ports:
# NOTE(danms): This loop can't fail to find a network since we
# filtered ports to only the ones matching networks above.
for net in networks:
if port['network_id'] == net['id']:
network_name = net['name']
break
network_IPs = []
for fixed_ip in port['fixed_ips']:
fixed = network_model.FixedIP(address=fixed_ip['ip_address'])
floats = self._get_floating_ips_by_fixed_and_port(
client, fixed_ip['ip_address'], port['id'])
for ip in floats:
fip = network_model.IP(address=ip['floating_ip_address'],
type='floating')
fixed.add_floating_ip(fip)
network_IPs.append(fixed)
subnets = self._get_subnets_from_port(context, port)
for subnet in subnets:
subnet['ips'] = [
fixed_ip for fixed_ip in network_IPs
if fixed_ip.is_in_subnet(subnet)
]
bridge = None
ovs_interfaceid = None
# Network model metadata
should_create_bridge = None
vif_type = port.get('binding:vif_type')
# TODO(berrange) Quantum should pass the bridge name
# in another binding metadata field
if vif_type == network_model.VIF_TYPE_OVS:
bridge = CONF.quantum_ovs_bridge
ovs_interfaceid = port['id']
elif vif_type == network_model.VIF_TYPE_BRIDGE:
bridge = "brq" + port['network_id']
should_create_bridge = True
if bridge is not None:
bridge = bridge[:network_model.NIC_NAME_LEN]
devname = "tap" + port['id']
devname = devname[:network_model.NIC_NAME_LEN]
network = network_model.Network(id=port['network_id'],
bridge=bridge,
injected=CONF.flat_injected,
label=network_name,
tenant_id=net['tenant_id'])
network['subnets'] = subnets
if should_create_bridge is not None:
network['should_create_bridge'] = should_create_bridge
nw_info.append(
network_model.VIF(id=port['id'],
address=port['mac_address'],
network=network,
type=port.get('binding:vif_type'),
ovs_interfaceid=ovs_interfaceid,
devname=devname))
return nw_info
def test_equate_two_dissimilar_fixed_ips_fails(self):
fixed_ip = model.FixedIP(address='::1')
fixed_ip2 = model.FixedIP(address='::2')
self.assertNotEqual(fixed_ip, fixed_ip2)
def _build_network_info_model(self, context, instance, networks=None):
search_opts = {
'tenant_id': instance['project_id'],
'device_id': instance['uuid'],
}
data = quantumv2.get_client(context,
admin=True).list_ports(**search_opts)
ports = data.get('ports', [])
if networks is None:
networks = self._get_available_networks(context,
instance['project_id'])
else:
# ensure ports are in preferred network order
_ensure_requested_network_ordering(lambda x: x['network_id'],
ports,
[n['id'] for n in networks])
nw_info = network_model.NetworkInfo()
for port in ports:
network_name = None
for net in networks:
if port['network_id'] == net['id']:
network_name = net['name']
break
if network_name is None:
raise exception.NotFound(
_('Network %(net)s for '
'port %(port_id)s not found!') % {
'net': port['network_id'],
'port': port['id']
})
network_IPs = [
network_model.FixedIP(address=ip_address) for ip_address in
[ip['ip_address'] for ip in port['fixed_ips']]
]
# TODO(gongysh) get floating_ips for each fixed_ip
subnets = self._get_subnets_from_port(context, port)
for subnet in subnets:
subnet['ips'] = [
fixed_ip for fixed_ip in network_IPs
if fixed_ip.is_in_subnet(subnet)
]
bridge = None
ovs_interfaceid = None
# Network model metadata
should_create_bridge = None
vif_type = port.get('binding:vif_type')
# TODO(berrange) Quantum should pass the bridge name
# in another binding metadata field
if vif_type == network_model.VIF_TYPE_OVS:
bridge = CONF.quantum_ovs_bridge
ovs_interfaceid = port['id']
elif vif_type == network_model.VIF_TYPE_BRIDGE:
bridge = "brq" + port['network_id']
should_create_bridge = True
if bridge is not None:
bridge = bridge[:network_model.NIC_NAME_LEN]
devname = "tap" + port['id']
devname = devname[:network_model.NIC_NAME_LEN]
network = network_model.Network(id=port['network_id'],
bridge=bridge,
injected=CONF.flat_injected,
label=network_name,
tenant_id=net['tenant_id'])
network['subnets'] = subnets
if should_create_bridge is not None:
network['should_create_bridge'] = should_create_bridge
nw_info.append(
network_model.VIF(id=port['id'],
address=port['mac_address'],
network=network,
type=port.get('binding:vif_type'),
ovs_interfaceid=ovs_interfaceid,
devname=devname))
return nw_info
