def test_create_lots_of_shared_ips_same_tenant_raises(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[1]['id'], ports[2]['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[2]['id'], ports[3]['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, network_id=net['id'], version=4)} with self.assertRaises(q_exc.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip)
def test_create_lots_of_shared_ips_same_tenant_raises(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[1]['id'], ports[2]['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[2]['id'], ports[3]['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, network_id=net['id'], version=4) } with self.assertRaises(q_exc.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ips_fails_with_garbage_body(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 = {"derpie_derp": dict(port_ids=port_ids, network_id=net["id"], version=4)} with self.assertRaises(n_exc.BadRequest): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ips_fails_with_plural_body(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_addresses': dict(port_ids=port_ids, network_id=net['id'], version=4)} with self.assertRaises(exceptions.BadRequest): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ip_over_isolated_total_ip_on_port_quota(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)} # NOTE(roaet): this is hardcoded to 5 should fail after 4 # since a port comes with 1 IP already for i in xrange(4): ip_api.create_ip_address(self.context, shared_ip) with self.assertRaises(n_exc.OverQuota): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ips_fails_with_garbage_body(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 = { 'derpie_derp': dict(port_ids=port_ids, network_id=net['id'], version=4) } with self.assertRaises(n_exc.BadRequest): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ip_over_service_total_ip_on_port_quota(self): network = dict( name="service", tenant_id="fake", network_plugin="BASE", id="11111111-1111-1111-1111-111111111111" ) network = {"network": network} with self._stubs(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)} # NOTE(roaet): this is hardcoded to 1 so should fail immediately with self.assertRaises(n_exc.OverQuota): ip_api.create_ip_address(self.context, shared_ip)
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_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_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): 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_create_ip_over_isolated_network_quota(self): with self._stubs(self.network, self.subnet, self.ports) as ( net, sub, ports): port_ids = [ports[0]['id']] ip_address = {'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4)} # NOTE: This is hardcoded to 5. Port comes with an IP # Can create 4 more before it fails for i in xrange(4): ip_api.create_ip_address(self.context, ip_address) # NOTE: This should raise an exception with self.assertRaises(q_exc.CannotAddMoreIPsToPort): ip_api.create_ip_address(self.context, ip_address)
def test_create_shared_ip_over_service_network_quota(self): network = dict(name="service", tenant_id="fake", network_plugin="BASE", id='11111111-1111-1111-1111-111111111111') network = {"network": network} with self._stubs(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)} # NOTE(roaet): this is hardcoded to 0 so should fail instantly with self.assertRaises(q_exceptions.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip)
def test_create_ip_over_service_network_quota(self): network = dict(name="service", network_plugin="BASE", id='11111111-1111-1111-1111-111111111111') network = {"network": network} with self._stubs(network, self.subnet, self.ports) as ( net, sub, ports): port_ids = [ports[0]['id']] ip_address = {'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4)} # NOTE : This is hardcoded to 1 and should raise an exception # as ports come with 1 IP with self.assertRaises(q_exc.CannotAddMoreIPsToPort): ip_api.create_ip_address(self.context, ip_address)
def test_create_shared_ip_over_isolated_total_ip_on_port_quota(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) } # NOTE(roaet): this is hardcoded to 5 should fail after 4 # since a port comes with 1 IP already for i in xrange(4): ip_api.create_ip_address(self.context, shared_ip) with self.assertRaises(n_exc.OverQuota): ip_api.create_ip_address(self.context, shared_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_create_shared_ip_over_public_total_ip_on_port_quota(self): network = dict( name="public", tenant_id="fake", network_plugin="BASE", id="00000000-0000-0000-0000-000000000000" ) network = {"network": network} with self._stubs(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)} # NOTE(roaet): this is hardcoded to 6 so should fail after 5 # since a port comes with 1 IP already for i in xrange(5): ip_api.create_ip_address(self.context, shared_ip) with self.assertRaises(n_exc.OverQuota): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ip_over_service_total_ip_on_port_quota(self): network = dict(name="service", tenant_id="fake", network_plugin="BASE", id='11111111-1111-1111-1111-111111111111') network = {"network": network} with self._stubs(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) } # NOTE(roaet): this is hardcoded to 1 so should fail immediately with self.assertRaises(n_exc.OverQuota): ip_api.create_ip_address(self.context, shared_ip)
def test_can_delete_ip_without_active_port(self): with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports): 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) ip_api.delete_ip_address(self.context, ip["id"]) with self.assertRaises(q_exc.IpAddressNotFound): ip_api.get_ip_address(self.context, ip["id"])
def test_create_shared_ip_over_service_network_quota(self): network = dict(name="service", tenant_id="fake", network_plugin="BASE", id='11111111-1111-1111-1111-111111111111') network = {"network": network} with self._stubs(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) } # NOTE(roaet): this is hardcoded to 0 so should fail instantly with self.assertRaises(q_exceptions.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip)
def test_cannot_delete_ip_with_active_port(self): with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports): 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")) with self.assertRaises(self.disassociate_exception): ip_api.delete_ip_address(self.context, ip["id"])
def test_create_ip_over_public_network_quota(self): network = dict(name="public", tenant_id="fake", network_plugin="BASE", id='00000000-0000-0000-0000-000000000000') network = {"network": network} with self._stubs(network, self.subnet, self.ports) as ( net, sub, ports): port_ids = [ports[0]['id']] ip_address = {'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4)} # NOTE: This is hardcoded to 6. Port comes with an IP # Can create 5 more before it fails for i in xrange(5): ip_api.create_ip_address(self.context, ip_address) # NOTE: This should raise an exception with self.assertRaises(q_exc.CannotAddMoreIPsToPort): ip_api.create_ip_address(self.context, ip_address)
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_create_shared_ip_over_public_network_quota(self): network = dict(name="public", tenant_id="fake", network_plugin="BASE", id='00000000-0000-0000-0000-000000000000') network = {"network": network} with self._stubs(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)} port_ids = [ports[2]['id'], ports[3]['id']] shared_ip2 = {'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4)} # NOTE(roaet): this is hardcoded to 5 and will fail after 5 for i in xrange(5): # NOTE(roaet): need to do this modulo stuff to not hit IP quota if i % 2 == 0: ip_api.create_ip_address(self.context, shared_ip) else: ip_api.create_ip_address(self.context, shared_ip2) with self.assertRaises(q_exceptions.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ip_over_public_network_quota(self): network = dict(name="public", tenant_id="fake", network_plugin="BASE", id='00000000-0000-0000-0000-000000000000') network = {"network": network} with self._stubs(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) } port_ids = [ports[2]['id'], ports[3]['id']] shared_ip2 = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4) } # NOTE(roaet): this is hardcoded to 5 and will fail after 5 for i in xrange(5): # NOTE(roaet): need to do this modulo stuff to not hit IP quota if i % 2 == 0: ip_api.create_ip_address(self.context, shared_ip) else: ip_api.create_ip_address(self.context, shared_ip2) with self.assertRaises(q_exc.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip)
def test_create_shared_ip_over_isolated_network_quota(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) } port_ids = [ports[2]['id'], ports[3]['id']] shared_ip2 = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4) } # NOTE(roaet): this is hardcoded to 5 for i in xrange(4): # NOTE(roaet): need to do this modulo stuff to not hit IP quota if i % 2 == 0: ip_api.create_ip_address(self.context, shared_ip) else: ip_api.create_ip_address(self.context, shared_ip2) # NOTE(roaet): this should not fail ip_api.create_ip_address(self.context, shared_ip)
def test_update_shared_ip_with_garbage_will_error(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 = {"delasdfkj": dict(port_ids=port_ids)} with self.assertRaises(n_exc.BadRequest): ip_api.update_ip_address(self.context, ip["id"], shared_ip)
def test_can_delete_ip_without_active_port(self): with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports): 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) ip_api.delete_ip_address(self.context, ip['id']) with self.assertRaises(q_exc.IpAddressNotFound): ip_api.get_ip_address(self.context, ip['id'])
def test_create_shared_ip_over_public_total_ip_on_port_quota(self): network = dict(name="public", tenant_id="fake", network_plugin="BASE", id='00000000-0000-0000-0000-000000000000') network = {"network": network} with self._stubs(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) } # NOTE(roaet): this is hardcoded to 6 so should fail after 5 # since a port comes with 1 IP already for i in xrange(5): ip_api.create_ip_address(self.context, shared_ip) with self.assertRaises(n_exc.OverQuota): ip_api.create_ip_address(self.context, shared_ip)
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_empty_port_id_list_will_error(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 = [] shared_ip = {'ip_addresses': dict(port_ids=port_ids)} with self.assertRaises(exceptions.BadRequest): ip_api.update_ip_address(self.context, ip['id'], shared_ip)
def test_has_shared_owner_detection(self): with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports): port_ids = [ports[0]["id"], ports[1]["id"]] p_id = ports[0]["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"]) ip_db = db_api.ip_address_find(self.context, id=ip["id"], scope=db_api.ONE) self.assertFalse(ip_db.has_any_shared_owner()) port_ip_update = ip_api.update_port_for_ip_address port_ip_update(self.context, ip["id"], p_id, self._make_port_body("derp")) self.assertTrue(ip_db.has_any_shared_owner())
def test_cannot_delete_ip_with_active_port(self): with self._stubs(self.network, self.subnet, self.ports_info2) as (net, sub, ports): 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')) with self.assertRaises(self.disassociate_exception): ip_api.delete_ip_address(self.context, ip['id'])
def test_delete_ip_with_shared_owner_error(self): with self._stubs(self.network, self.subnet, self.ports_info2) as ( net, sub, ports): port_ids = [ports[0]['id'], ports[1]['id']] p_id = ports[0]['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) port_ip_update = ip_api.update_port_for_ip_address port_ip_update(self.context, ip['id'], p_id, self._make_port_body('derp')) with self.assertRaises(self.disassociate_exception): ip_api.delete_ip_address(self.context, ip['id'])
def test_update_shared_ip_with_garbage_will_error(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 = {'delasdfkj': dict(port_ids=port_ids)} with self.assertRaises(n_exc.BadRequest): ip_api.update_ip_address(self.context, ip['id'], shared_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_update_shared_ip_with_owned_port_no_error_if_same_list(self): with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports): port_ids = [ports[0]["id"], ports[1]["id"]] p_id = ports[0]["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_ip_update = ip_api.update_port_for_ip_address port_ip_update(self.context, ip["id"], p_id, self._make_port_body("derp")) shared_ip = {"ip_address": dict(port_ids=port_ids)} ip_api.update_ip_address(self.context, ip["id"], shared_ip)
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_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_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_owned_port_no_error_if_adding(self): with self._stubs(self.network, self.subnet, self.ports_info4) as ( net, sub, ports): port_ids = [ports[0]['id'], ports[1]['id']] p_id = ports[0]['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_ip_update = ip_api.update_port_for_ip_address port_ip_update(self.context, ip['id'], p_id, self._make_port_body('derp')) port_ids = [ports[0]['id'], ports[1]['id'], ports[2]['id']] shared_ip = {'ip_address': dict(port_ids=port_ids)} ip_api.update_ip_address(self.context, ip['id'], shared_ip)
def test_update_shared_ip_with_owned_port_no_error_if_same_list(self): with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports): port_ids = [ports[0]['id'], ports[1]['id']] p_id = ports[0]['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_ip_update = ip_api.update_port_for_ip_address port_ip_update(self.context, ip['id'], p_id, self._make_port_body('derp')) shared_ip = {'ip_address': dict(port_ids=port_ids)} ip_api.update_ip_address(self.context, ip['id'], shared_ip)
def test_has_shared_owner_detection(self): with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports): port_ids = [ports[0]['id'], ports[1]['id']] p_id = ports[0]['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']) ip_db = db_api.ip_address_find(self.context, id=ip['id'], scope=db_api.ONE) self.assertFalse(ip_db.has_any_shared_owner()) port_ip_update = ip_api.update_port_for_ip_address port_ip_update(self.context, ip['id'], p_id, self._make_port_body('derp')) self.assertTrue(ip_db.has_any_shared_owner())
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_ip_over_isolated_network_quota(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)} port_ids = [ports[2]["id"], ports[3]["id"]] shared_ip2 = {"ip_address": dict(port_ids=port_ids, network_id=net["id"], version=4)} # NOTE(roaet): this is hardcoded to 5 for i in xrange(4): # NOTE(roaet): need to do this modulo stuff to not hit IP quota if i % 2 == 0: ip_api.create_ip_address(self.context, shared_ip) else: ip_api.create_ip_address(self.context, shared_ip2) # NOTE(roaet): this should not fail ip_api.create_ip_address(self.context, shared_ip)
def create_ip_address(self, context, ip_address): self._fix_missing_tenant_id(context, ip_address["ip_address"]) return ip_addresses.create_ip_address(context, ip_address)
def test_create_lots_of_shared_ips_diff_tenant_raises(self): with self._stubs(self.network, self.subnet, self.ports_info4) as (net, sub, ports): derp_ports = [] derp_context = context.Context("derp", "derp", is_admin=True) for port_info in self.ports_info2_other: port_info['port']['network_id'] = net['id'] port = port_api.create_port(derp_context, port_info) self.assertEqual("derp", port['tenant_id']) derp_ports.append(port) port_ids = [derp_ports[0]['id'], derp_ports[1]['id']] shared_ip = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4, tenant_id="derp") } ip = ip_api.create_ip_address(derp_context, shared_ip) self.assertEqual(ip_types.SHARED, ip['type']) self.assertEqual("derp", ip['tenant_id']) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(1, len(ips)) port_ids = [ports[1]['id'], ports[2]['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']) self.assertEqual("fake", ip['tenant_id']) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(2, len(ips)) port_ids = [ports[2]['id'], ports[3]['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']) self.assertEqual("fake", ip['tenant_id']) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(3, len(ips)) port_ids = [ports[0]['id'], ports[3]['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']) self.assertEqual("fake", ip['tenant_id']) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(4, len(ips)) # total shared IPs on network ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], tenant_id=self.context.tenant_id, address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(3, len(ips)) port_ids = [ports[0]['id'], ports[1]['id']] shared_ip = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4) } with self.assertRaises(q_exc.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.context, shared_ip) port_ids = [derp_ports[1]['id'], derp_ports[2]['id']] shared_ip = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4, tenant_id="derp") } ip = ip_api.create_ip_address(derp_context, shared_ip) self.assertEqual(ip_types.SHARED, ip['type']) self.assertEqual("derp", ip['tenant_id']) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(5, len(ips)) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], tenant_id='derp', address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(2, len(ips)) port_ids = [derp_ports[0]['id'], derp_ports[2]['id']] shared_ip = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4, tenant_id="derp") } ip = ip_api.create_ip_address(derp_context, shared_ip) self.assertEqual(ip_types.SHARED, ip['type']) self.assertEqual("derp", ip['tenant_id']) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(6, len(ips)) ips = db_api.ip_address_find(self.admin_context, network_id=net['id'], tenant_id='derp', address_type=ip_types.SHARED, scope=db_api.ALL) self.assertEqual(3, len(ips)) port_ids = [derp_ports[0]['id'], derp_ports[2]['id']] shared_ip = { 'ip_address': dict(port_ids=port_ids, network_id=net['id'], version=4, tenant_id="derp") } with self.assertRaises(q_exc.CannotCreateMoreSharedIPs): ip_api.create_ip_address(self.admin_context, shared_ip)
def create_ip_address(self, context, ip_address): return ip_addresses.create_ip_address(context, ip_address)
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))