def test_get_ports_filter_with_ip_and_device(self):
with self._stubs(self.network, self.subnet, self.ports_info4) as (
net, sub, ports):
network = dict(name="xx", tenant_id="fake", network_plugin="BASE")
xx_network = {"network": network}
xx_net = network_api.create_network(self.context, xx_network)
subnet = dict(id=2, ip_version=4, next_auto_assign_ip=2,
cidr=self.cidr, first_ip=self.ip_network.first,
last_ip=self.ip_network.last, ip_policy=None,
tenant_id="fake")
xx_subnet = {"subnet": subnet}
xx_subnet['subnet']['network_id'] = xx_net['id']
subnet_api.create_subnet(self.context, xx_subnet)
port_info = {'port': dict(device_id='a')}
port_info['port']['network_id'] = xx_net['id']
port_api.create_port(self.context, port_info)
port_ids1 = [ports[0]['id'], ports[1]['id']]
shared_ip1 = {'ip_address': dict(port_ids=port_ids1,
network_id=net['id'],
version=4)}
ip1 = ip_api.create_ip_address(self.context, shared_ip1)
filters = dict(device_id='a')
ports = ip_api.get_ports_for_ip_address(self.context, ip1['id'],
filters=filters)
self.assertEqual(1, len(ports))
filters = dict(device_id='a')
ports = port_api.get_ports(self.context, filters=filters)
self.assertEqual(2, len(ports))
def test_create_shared_ips_with_port_ids(self):
def _make_body(ip):
fix_ip = dict(ip_address=ip, subnet_id=sub['id'])
port_info = {"port": dict(fixed_ips=[fix_ip])}
return port_info
with self._stubs(self.network, self.subnet, self.ports_info2) as (
net, sub, ports):
for p in ports:
port_db = db_api.port_find(self.context, id=p['id'],
scope=db_api.ONE)
assocs = db_api.ip_port_association_find(self.context,
scope=db_api.ALL,
port_id=p['id'])
self.assertEqual(1, len(p.get('fixed_ips')))
self.assertEqual(1, len(port_db.ip_addresses))
ip_db = port_db.ip_addresses[0]
self.assertEqual('none', ip_db.get_service_for_port(port_db))
self.assertEqual(1, len(assocs))
port_ids = [ports[0]['id'], ports[1]['id']]
shared_ip = {'ip_address': dict(port_ids=port_ids,
network_id=net['id'],
version=4)}
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip['type'])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
def test_ip_port_list_has_services(self):
with self._stubs(self.network, self.subnet, self.ports_info2) as (
net, sub, ports):
for port in ports:
self.assertEqual(1, len(port['fixed_ips']))
device_ids = [ports[0]['device_id'], ports[1]['device_id']]
shared_ip = {'ip_address': dict(device_ids=device_ids,
network_id=net['id'],
version=4)}
ip = ip_api.create_ip_address(self.context, shared_ip)
port_ip_update = ip_api.update_port_for_ip_address
port_ip_update(self.context, ip['id'],
ports[0]['id'], self._make_port_body('derp'))
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
for port in ports_ip:
self.assertTrue('service' in port)
self.assertTrue('device_id' in port)
self.assertTrue('id' in port)
self.assertTrue(port['service'] in ('derp', 'none'),
'Service is: %s' % str(port['service']))
def test_shared_ip_in_fixed_ip_list(self):
with self._stubs(self.network, self.subnet, self.ports_info2) as (
net, sub, ports):
for port in ports:
self.assertEqual(1, len(port['fixed_ips']))
port_ids = [ports[0]['id'], ports[1]['id']]
shared_ip = {'ip_address': dict(port_ids=port_ids,
network_id=net['id'],
version=4)}
p_id = ports[0]['id']
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip['type'])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
port_ip_update = ip_api.update_port_for_ip_address
updated_port = port_ip_update(self.context, ip['id'],
p_id, self._make_port_body('derp'))
self.assertEqual('derp', updated_port.get('service'))
port = port_api.get_port(self.context, p_id)
self.assertEqual(2, len(port['fixed_ips']))
def test_ip_port_list_has_services(self):
with self._stubs(self.network, self.subnet,
self.ports_info2) as (net, sub, ports):
for port in ports:
self.assertEqual(1, len(port['fixed_ips']))
device_ids = [ports[0]['device_id'], ports[1]['device_id']]
shared_ip = {
'ip_address':
dict(device_ids=device_ids, network_id=net['id'], version=4)
}
ip = ip_api.create_ip_address(self.context, shared_ip)
port_ip_update = ip_api.update_port_for_ip_address
port_ip_update(self.context, ip['id'], ports[0]['id'],
self._make_port_body('derp'))
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
for port in ports_ip:
self.assertTrue('service' in port)
self.assertTrue('device_id' in port)
self.assertTrue('id' in port)
self.assertTrue(port['service'] in ('derp', 'none'),
'Service is: %s' % str(port['service']))
def test_shared_ip_in_fixed_ip_list(self):
with self._stubs(self.network, self.subnet,
self.ports_info2) as (net, sub, ports):
for port in ports:
self.assertEqual(1, len(port['fixed_ips']))
port_ids = [ports[0]['id'], ports[1]['id']]
shared_ip = {
'ip_address':
dict(port_ids=port_ids, network_id=net['id'], version=4)
}
p_id = ports[0]['id']
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip['type'])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
port_ip_update = ip_api.update_port_for_ip_address
updated_port = port_ip_update(self.context, ip['id'], p_id,
self._make_port_body('derp'))
self.assertEqual('derp', updated_port.get('service'))
port = port_api.get_port(self.context, p_id)
self.assertEqual(2, len(port['fixed_ips']))
def test_create_shared_ips_with_port_ids(self):
with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports):
port_ids = [ports[0]["id"], ports[1]["id"]]
shared_ip = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)}
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip["type"])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip["id"])
self.assertEqual(2, len(ports_ip))
def get_ports_for_ip_address(self,
context,
ip,
limit=None,
page_reverse=False,
sorts=['id'],
marker=None,
filters=None,
fields=None):
return ip_addresses.get_ports_for_ip_address(context, ip, limit, sorts,
marker, page_reverse,
filters, fields)
def test_ip_address_port_find_service(self):
net = db_api.network_create(self.context)
port = db_api.port_create(self.context, network_id=net["id"],
backend_key="", device_id="")
ip_address = db_api.ip_address_create(
self.context, address=netaddr.IPAddress("0.0.0.0"))
self.context.session.flush()
ip_address = db_api.port_associate_ip(self.context, [port], ip_address)
ip_address.set_service_for_port(port, "foobar")
self.context.session.flush()
ports = ip_api.get_ports_for_ip_address(
self.context, ip_address["id"],
filters={"service": "not-foobar"})
self.assertEqual(len(ports), 0)
ports = ip_api.get_ports_for_ip_address(
self.context, ip_address["id"],
filters={"service": "foobar"})
self.assertEqual(len(ports), 1)
def test_create_shared_ips_with_port_ids(self):
with self._stubs(self.network, self.subnet,
self.ports_info2) as (net, sub, ports):
port_ids = [ports[0]['id'], ports[1]['id']]
shared_ip = {
'ip_address':
dict(port_ids=port_ids, network_id=net['id'], version=4)
}
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip['type'])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
def test_update_shared_ip_with_unowned_ports_is_okay(self):
with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports):
port_ids = [ports[0]["id"], ports[1]["id"]]
shared_ip = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)}
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip["type"])
port_ids = [ports[0]["id"], ports[3]["id"]]
shared_ip = {"ip_address": dict(port_ids=port_ids)}
ip = ip_api.update_ip_address(self.context, ip["id"], shared_ip)
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip["id"])
self.assertEqual(2, len(ports_ip))
for port in ports_ip:
self.assertTrue(port["id"] in port_ids)
def test_shared_ip_in_fixed_ip_list(self):
def _make_body(service):
body = dict(service=service)
port_info = {"port": dict(body)}
return port_info
with self._stubs(self.network, self.subnet, self.ports_info2) as (
net, sub, ports):
for p in ports:
port_db = db_api.port_find(self.context, id=p['id'],
scope=db_api.ONE)
assocs = db_api.ip_port_association_find(self.context,
scope=db_api.ALL,
port_id=p['id'])
self.assertEqual(1, len(p.get('fixed_ips')))
self.assertEqual(1, len(port_db.ip_addresses))
ip_db = port_db.ip_addresses[0]
self.assertEqual('none', ip_db.get_service_for_port(port_db))
self.assertEqual(1, len(assocs))
device_ids = [ports[0]['device_id'], ports[1]['device_id']]
shared_ip = {'ip_address': dict(device_ids=device_ids,
network_id=net['id'],
version=4)}
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip['type'])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
port = port_api.get_port(self.context, ports[0]['id'])
self.assertEqual(2, len(port['fixed_ips']))
port_ip_update = ip_api.update_port_for_ip_address
updated_port = port_ip_update(self.context, ip['id'],
ports[0]['id'], _make_body('derp'))
self.assertEqual('derp', updated_port.get('service'))
port = ip_api.get_port_for_ip_address(self.context, ip['id'],
ports[0]['id'])
self.assertEqual('derp', port.get('service'))
port = ip_api.get_port_for_ip_address(self.context, ip['id'],
ports[1]['id'])
self.assertEqual('none', port.get('service'))
def test_ip_port_list_has_services(self):
with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports):
for port in ports:
self.assertEqual(1, len(port["fixed_ips"]))
device_ids = [ports[0]["device_id"], ports[1]["device_id"]]
shared_ip = {"ip_address": dict(device_ids=device_ids, network_id=net["id"], version=4)}
ip = ip_api.create_ip_address(self.context, shared_ip)
port_ip_update = ip_api.update_port_for_ip_address
port_ip_update(self.context, ip["id"], ports[0]["id"], self._make_port_body("derp"))
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip["id"])
self.assertEqual(2, len(ports_ip))
for port in ports_ip:
self.assertTrue("service" in port)
self.assertTrue("device_id" in port)
self.assertTrue("id" in port)
self.assertTrue(port["service"] in ("derp", "none"), "Service is: %s" % str(port["service"]))
def test_update_shared_ip_with_unowned_ports_is_okay(self):
with self._stubs(self.network, self.subnet,
self.ports_info4) as (net, sub, ports):
port_ids = [ports[0]['id'], ports[1]['id']]
shared_ip = {
'ip_address':
dict(port_ids=port_ids, network_id=net['id'], version=4)
}
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip['type'])
port_ids = [ports[0]['id'], ports[3]['id']]
shared_ip = {'ip_address': dict(port_ids=port_ids)}
ip = ip_api.update_ip_address(self.context, ip['id'], shared_ip)
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip['id'])
self.assertEqual(2, len(ports_ip))
for port in ports_ip:
self.assertTrue(port['id'] in port_ids)
def test_shared_ip_in_fixed_ip_list(self):
with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports):
for port in ports:
self.assertEqual(1, len(port["fixed_ips"]))
port_ids = [ports[0]["id"], ports[1]["id"]]
shared_ip = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)}
p_id = ports[0]["id"]
ip = ip_api.create_ip_address(self.context, shared_ip)
self.assertEqual(ip_types.SHARED, ip["type"])
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip["id"])
self.assertEqual(2, len(ports_ip))
port_ip_update = ip_api.update_port_for_ip_address
updated_port = port_ip_update(self.context, ip["id"], p_id, self._make_port_body("derp"))
self.assertEqual("derp", updated_port.get("service"))
port = port_api.get_port(self.context, p_id)
self.assertEqual(2, len(port["fixed_ips"]))
def get_ports_for_ip_address(self, context, ip, limit=None,
page_reverse=False, sorts=None, marker=None,
filters=None, fields=None):
return ip_addresses.get_ports_for_ip_address(context, ip, limit, sorts,
marker, page_reverse,
filters, fields)
def test_filter_ip_by_device_and_service(self):
def _make_body(service):
body = dict(service=service)
port_info = {"port": dict(body)}
return port_info
with self._stubs(self.network, self.subnet, self.ports_info4) as (
net, sub, ports):
port_ids1 = [ports[0]['id'], ports[1]['id']]
port_ids2 = [ports[2]['id'], ports[3]['id']]
filters = dict(device_id='a')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(1, len(ips))
shared_ip1 = {'ip_address': dict(port_ids=port_ids1,
network_id=net['id'],
version=4)}
ip1 = ip_api.create_ip_address(self.context, shared_ip1)
self.assertEqual(2, len(ip1['port_ids']))
shared_ip2 = {'ip_address': dict(port_ids=port_ids2,
network_id=net['id'],
version=4)}
ip2 = ip_api.create_ip_address(self.context, shared_ip2)
self.assertEqual(2, len(ip2['port_ids']))
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip1['id'])
self.assertEqual(2, len(ports_ip))
ports_ip = ip_api.get_ports_for_ip_address(self.context, ip2['id'])
self.assertEqual(2, len(ports_ip))
filters = dict(device_id='a')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(2, len(ips))
filters = dict(device_id='x')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(0, len(ips))
filters = dict(device_id='a', service='derp')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(0, len(ips))
filters = dict(service='derp')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(0, len(ips))
filters = dict(device_id='a', service='none')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(2, len(ips))
port_ip_update = ip_api.update_port_for_ip_address
updated_port = port_ip_update(self.context, ip1['id'],
ports[0]['id'], _make_body('derp'))
self.assertEqual('derp', updated_port.get('service'))
filters = dict(device_id='a', service='derp')
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(1, len(ips))
filters = dict(device_id='a', service='derp',
type=ip_types.FIXED)
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(0, len(ips))
filters = dict(device_id='a', service='derp',
type=ip_types.SHARED)
ips = ip_api.get_ip_addresses(self.context, **filters)
self.assertEqual(1, len(ips))
