Exemplo n.º 1
0
    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))
Exemplo n.º 2
0
    def _stubs(self):
        with mock.patch("neutron.common.rpc.get_notifier"), \
                mock.patch("neutron.quota.QUOTAS.limit_check"):
            mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
            self.context.is_admin = True
            macrng_api.create_mac_address_range(self.context, mac)
            self.context.is_admin = False
            network_info = dict(name="public",
                                tenant_id="fake",
                                network_plugin="BASE",
                                ipam_strategy="ANY")
            network_info = {"network": network_info}
            network = network_api.create_network(self.context, network_info)
            subnet = db_api.subnet_create(self.context,
                                          tenant_id="fake",
                                          cidr="192.168.10.0/24",
                                          network_id=network['id'])

            fixed_ips = [
                dict(subnet_id=subnet['id'],
                     enabled=True,
                     ip_address=self.addr)
            ]
            port = dict(port=dict(network_id=network['id'],
                                  tenant_id=self.context.tenant_id,
                                  device_id=2,
                                  fixed_ips=fixed_ips))
            port_api.create_port(self.context, port)
            self.context.is_admin = True
            filters = {"deallocated": "both"}
            ip = ip_addr.get_ip_addresses(self.context, **filters)
            self.context.is_admin = False
        yield ip[0]
Exemplo n.º 3
0
    def _stubs(self):
        with mock.patch("neutron.common.rpc.get_notifier"), \
                mock.patch("neutron.quota.QUOTAS.limit_check"):
            mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
            self.context.is_admin = True
            macrng_api.create_mac_address_range(self.context, mac)
            self.context.is_admin = False
            network_info = dict(name="public", tenant_id="fake",
                                network_plugin="BASE",
                                ipam_strategy="ANY")
            network_info = {"network": network_info}
            network = network_api.create_network(self.context, network_info)
            subnet = db_api.subnet_create(self.context, tenant_id="fake",
                                          cidr="192.168.10.0/24",
                                          network_id=network['id'])

            fixed_ips = [dict(subnet_id=subnet['id'], enabled=True,
                         ip_address=self.addr)]
            port = dict(port=dict(network_id=network['id'],
                                  tenant_id=self.context.tenant_id,
                                  device_id=2,
                                  fixed_ips=fixed_ips))
            port_api.create_port(self.context, port)
            self.context.is_admin = True
            filters = {"deallocated": "both"}
            ip = ip_addr.get_ip_addresses(self.context, **filters)
            self.context.is_admin = False
        yield ip[0]
Exemplo n.º 4
0
    def test_port_created_with_forbidden_mac_range(self):
        cidr = "192.168.1.0/24"
        ip_network = netaddr.IPNetwork(cidr)
        network = dict(id='1', name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1', ip_version=4, next_auto_assign_ip=2,
                         cidr=cidr, first_ip=ip_network.first,
                         last_ip=ip_network.last, ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        def _make_body(use_forbidden_mac_range=False):
            fix_ipv4 = dict(subnet_id=sub_v4s[0]['id'])
            port_info = \
                {"port": dict(
                    fixed_ips=[fix_ipv4], network_id=net['id'],
                    use_forbidden_mac_range=use_forbidden_mac_range
                )}
            return port_info

        with self._stubs(network, [subnet_v4_info]) as (
                net, sub_v4s, sub_v6):
            admin_ctxt = self.context.elevated()

            port = port_api.create_port(
                admin_ctxt, _make_body(use_forbidden_mac_range=True))
            port_mac = port["mac_address"]

            self.assertTrue(port_mac.startswith("AA:BB:CC"))

            with self.assertRaises(q_exc.MacAddressGenerationFailure):
                port_api.create_port(admin_ctxt,
                                     _make_body())
Exemplo n.º 5
0
    def test_port_created_doesnt_satisfy_ipam_strategy_raises(self):
        cidr = "192.168.1.0/24"
        ip_network = netaddr.IPNetwork(cidr)
        network = dict(id=1,
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="BOTH_REQUIRED")
        network = {"network": network}
        subnet_v4 = dict(id=1,
                         ip_version=4,
                         next_auto_assign_ip=2,
                         cidr=cidr,
                         first_ip=ip_network.first,
                         last_ip=ip_network.last,
                         ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        def _make_body_only_v4(ip):
            fix_ip = dict(ip_address=ip, subnet_id=sub_v4['id'])
            port_info = {
                "port": dict(fixed_ips=[fix_ip], network_id=net['id'])
            }
            return port_info

        with self._stubs(network, subnet_v4_info) as (net, sub_v4, sub_v6):
            ip = "192.168.1.50"
            with self.assertRaises(q_exc.IpAddressGenerationFailure):
                port_api.create_port(self.context, _make_body_only_v4(ip))
Exemplo n.º 6
0
    def test_gather_sg_ports(self):
        """Checking if gather ports works as designed. """
        cidr = "192.168.1.0/24"
        network = dict(id='1',
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1', ip_version=4, cidr=cidr, tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        with self._stubs(network, subnet_v4_info) as (net, sub_v4, update):
            port1 = port_api.create_port(self.context, self._make_body(net))
            self.assertIsNotNone(port1)
            port2 = port_api.create_port(self.context, self._make_body(net))
            self.assertIsNotNone(port2)

            sg_body = dict(tenant_id="derp",
                           name="test sg",
                           description="none")
            sg_body = dict(security_group=sg_body)

            sg = sg_api.create_security_group(self.context, sg_body)
            self.assertIsNotNone(sg)
            sgid = sg['id']
            self.assertIsNotNone(sgid)

            assoc_ports = self._get_assoc_ports(sgid)
            self.assertEqual(0, len(assoc_ports))

            port_body = {'security_groups': [sgid]}
            port_body = dict(port=port_body)

            port1 = port_api.update_port(self.context, port1['id'], port_body)
            self.assertIsNotNone(port1)

            assoc_ports = self._get_assoc_ports(sgid)
            self.assertEqual(1, len(assoc_ports))

            # NOTE: this is duplicated because update_port modifies the params
            port_body = {'security_groups': [sgid]}
            port_body = dict(port=port_body)

            port2 = port_api.update_port(self.context, port2['id'], port_body)
            self.assertIsNotNone(port2)

            assoc_ports = self._get_assoc_ports(sgid)
            self.assertEqual(2, len(assoc_ports))
Exemplo n.º 7
0
 def test_port_show(self):
     with self._stubs(self.net_info, self.sub_info) as (network, subnet):
         fixed_ips = [
             dict(subnet_id=subnet['id'],
                  enabled=True,
                  ip_address="192.168.10.45"),
             dict(subnet_id=subnet['id'],
                  enabled=True,
                  ip_address="192.168.10.199")
         ]
         port = dict(port=dict(network_id=network['id'],
                               tenant_id=self.context.tenant_id,
                               device_id='2',
                               fixed_ips=fixed_ips))
         expected = {
             'status': "ACTIVE",
             'device_owner': None,
             'network_id': network["id"],
             'tenant_id': self.context.tenant_id,
             'admin_state_up': True,
             'fixed_ips': fixed_ips,
             'device_id': '2'
         }
         result = port_api.create_port(self.context, port)
         result = port_api.get_port(self.context, result['id'])
         for key in expected.keys():
             if key != 'fixed_ips':
                 self.assertEqual(result[key], expected[key],
                                  "Mismatch on %s" % key)
         for ip in result['fixed_ips']:
             self.assertTrue(ip in fixed_ips,
                             '%s not in %s' % (ip, expected['fixed_ips']))
Exemplo n.º 8
0
 def test_create_port_multiple_fixed_ipv6(self):
     with self._stubs(self.net_info, self.sub_info_v6) as (network, subnet):
         ipv6a = "2001:db8::10"
         ipv6b = "2001:db8::15"
         fixed_ips = [
             dict(subnet_id=subnet['id'], enabled=True, ip_address=ipv6a),
             dict(subnet_id=subnet['id'], enabled=True, ip_address=ipv6b)
         ]
         port = dict(port=dict(network_id=network['id'],
                               tenant_id=self.context.tenant_id,
                               device_id=2,
                               fixed_ips=fixed_ips))
         expected = {
             'status': "ACTIVE",
             'device_owner': None,
             'network_id': network["id"],
             'tenant_id': self.context.tenant_id,
             'admin_state_up': True,
             'fixed_ips': fixed_ips,
             'device_id': 2
         }
         result = port_api.create_port(self.context, port)
         for key in expected.keys():
             if key != 'fixed_ips':
                 self.assertEqual(result[key], expected[key],
                                  "Mismatch on %s" % key)
         for ip in result['fixed_ips']:
             self.assertTrue(ip in expected['fixed_ips'])
Exemplo n.º 9
0
 def test_port_show(self):
     with self._stubs(self.net_info, self.sub_info) as (network, subnet):
         fixed_ips = [dict(subnet_id=subnet['id'], enabled=True,
                      ip_address="192.168.10.45"),
                      dict(subnet_id=subnet['id'], enabled=True,
                      ip_address="192.168.10.199")]
         port = dict(port=dict(network_id=network['id'],
                               tenant_id=self.context.tenant_id,
                               device_id='2',
                               fixed_ips=fixed_ips))
         expected = {'status': "ACTIVE",
                     'device_owner': None,
                     'network_id': network["id"],
                     'tenant_id': self.context.tenant_id,
                     'admin_state_up': True,
                     'fixed_ips': fixed_ips,
                     'device_id': '2'}
         result = port_api.create_port(self.context, port)
         result = port_api.get_port(self.context, result['id'])
         for key in expected.keys():
             if key != 'fixed_ips':
                 self.assertEqual(result[key], expected[key],
                                  "Mismatch on %s" % key)
         for ip in result['fixed_ips']:
             self.assertTrue(ip in fixed_ips,
                             '%s not in %s' % (ip, expected['fixed_ips']))
Exemplo n.º 10
0
    def test_port_created_with_only_subnet(self):
        cidr = "192.168.1.0/24"
        ip_network = netaddr.IPNetwork(cidr)
        network = dict(id='1',
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1',
                         ip_version=4,
                         next_auto_assign_ip=2,
                         cidr=cidr,
                         first_ip=ip_network.first,
                         last_ip=ip_network.last,
                         ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        def _make_body():
            fix_ipv4 = dict(subnet_id=sub_v4s[0]['id'])
            port_info = {
                "port": dict(fixed_ips=[fix_ipv4], network_id=net['id'])
            }
            return port_info

        with self._stubs(network, [subnet_v4_info]) as (net, sub_v4s, sub_v6):

            port = port_api.create_port(self.context, _make_body())
            port_ip = port["fixed_ips"][0]["ip_address"]

            self.assertTrue(
                netaddr.IPAddress(port_ip) in netaddr.IPNetwork(cidr))
Exemplo n.º 11
0
    def test_port_created_with_only_subnet(self):
        cidr = "192.168.1.0/24"
        ip_network = netaddr.IPNetwork(cidr)
        network = dict(id=1, name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id=1, ip_version=4, next_auto_assign_ip=2,
                         cidr=cidr, first_ip=ip_network.first,
                         last_ip=ip_network.last, ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        def _make_body():
            fix_ipv4 = dict(subnet_id=sub_v4s[0]['id'])
            port_info = {"port": dict(fixed_ips=[fix_ipv4],
                                      network_id=net['id'])}
            return port_info

        with self._stubs(network, [subnet_v4_info]) as (
                net, sub_v4s, sub_v6):

            port = port_api.create_port(self.context, _make_body())
            port_ip = port["fixed_ips"][0]["ip_address"]

            self.assertTrue(netaddr.IPAddress(port_ip) in
                            netaddr.IPNetwork(cidr))
Exemplo n.º 12
0
 def test_create_port_multiple_fixed_ipv6(self):
     with self._stubs(self.net_info, self.sub_info_v6) as (network, subnet):
         ipv6a = "2001:db8::10"
         ipv6b = "2001:db8::15"
         fixed_ips = [dict(subnet_id=subnet['id'], enabled=True,
                      ip_address=ipv6a),
                      dict(subnet_id=subnet['id'], enabled=True,
                      ip_address=ipv6b)]
         port = dict(port=dict(network_id=network['id'],
                               tenant_id=self.context.tenant_id,
                               device_id=2,
                               fixed_ips=fixed_ips))
         expected = {'status': "ACTIVE",
                     'device_owner': None,
                     'network_id': network["id"],
                     'tenant_id': self.context.tenant_id,
                     'admin_state_up': True,
                     'fixed_ips': fixed_ips,
                     'device_id': 2}
         result = port_api.create_port(self.context, port)
         for key in expected.keys():
             if key != 'fixed_ips':
                 self.assertEqual(result[key], expected[key],
                                  "Mismatch on %s" % key)
         for ip in result['fixed_ips']:
             self.assertTrue(ip in expected['fixed_ips'])
Exemplo n.º 13
0
    def test_gather_sg_ports(self):
        """Checking if gather ports works as designed. """
        cidr = "192.168.1.0/24"
        network = dict(id='1', name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1', ip_version=4, cidr=cidr,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        with self._stubs(network, subnet_v4_info) as (net, sub_v4, update):
            port1 = port_api.create_port(self.context, self._make_body(net))
            self.assertIsNotNone(port1)
            port2 = port_api.create_port(self.context, self._make_body(net))
            self.assertIsNotNone(port2)

            sg_body = dict(tenant_id="derp", name="test sg",
                           description="none")
            sg_body = dict(security_group=sg_body)

            sg = sg_api.create_security_group(self.context, sg_body)
            self.assertIsNotNone(sg)
            sgid = sg['id']
            self.assertIsNotNone(sgid)

            assoc_ports = self._get_assoc_ports(sgid)
            self.assertEqual(0, len(assoc_ports))

            port_body = {'security_groups': [sgid]}
            port_body = dict(port=port_body)

            port1 = port_api.update_port(self.context, port1['id'], port_body)
            self.assertIsNotNone(port1)

            assoc_ports = self._get_assoc_ports(sgid)
            self.assertEqual(1, len(assoc_ports))

            # NOTE: this is duplicated because update_port modifies the params
            port_body = {'security_groups': [sgid]}
            port_body = dict(port=port_body)

            port2 = port_api.update_port(self.context, port2['id'], port_body)
            self.assertIsNotNone(port2)

            assoc_ports = self._get_assoc_ports(sgid)
            self.assertEqual(2, len(assoc_ports))
Exemplo n.º 14
0
    def test_ports_pagination(self):
        cidr = "192.168.1.0/24"

        ip_network = netaddr.IPNetwork(cidr)

        network = dict(id="1",
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}

        subnet = dict(id="1",
                      ip_version=4,
                      next_auto_assign_ip=2,
                      cidr=cidr,
                      first_ip=ip_network.first,
                      last_ip=ip_network.last,
                      ip_policy=None,
                      tenant_id="fake")
        subnet_info = {"subnet": subnet}

        def _make_body():
            fix_ipv4 = dict(subnet_id=sub_ports[0]['id'])
            port_info = {
                "port": dict(fixed_ips=[fix_ipv4], network_id=net['id'])
            }
            return port_info

        ports_per_page = 1
        with self._stubs(network, subnet_info) as (net, sub_ports):
            port1 = port_api.create_port(self.context, _make_body())
            port2 = port_api.create_port(self.context, _make_body())
            res_ports = port_api.get_ports(self.context, ports_per_page,
                                           ['id'], None)
            self.assertEqual(len(res_ports), ports_per_page)
            res_ports = port_api.get_ports(self.context)
            self.assertNotEqual(len(res_ports), ports_per_page)
            # Note (Perkins): Testing for a default sort on created_at,
            # but created_at is not available, so check that mac addresses,
            # which are created sequentially, are ordered correctly.
            res_ports = port_api.get_ports(self.context, 2, ['mac_address'],
                                           None)
            self.assertTrue(
                res_ports[0]['mac_address'] < res_ports[1]['mac_address'])
            self.assertTrue(port1['id'] == res_ports[0]['id'])
            self.assertTrue(port2['id'] == res_ports[1]['id'])
Exemplo n.º 15
0
 def test_can_create_port_with_adv_svc(self):
     with self._stubs(self.net_info, self.sub_info) as (network, subnet):
         port_info = {'port': {'network_id': network['id'],
                               'tenant_id': 'someoneelse'}}
         self.context.is_admin = True
         self.context.is_advsvc = True
         port_mod = port_api.create_port(self.context, port_info)
         self.assertIsNotNone(port_mod['id'])
         self.assertNotEqual(port_mod['tenant_id'], network['tenant_id'])
Exemplo n.º 16
0
    def test_env_caps_off_sg_async_update(self):
        """This test ensures that envcaps off works as designed."""
        env_set = [
            env.Capabilities.SECURITY_GROUPS,
            env.Capabilities.TENANT_NETWORK_SG,
            env.Capabilities.EGRESS,
        ]
        override = ','.join(env_set)
        old_override = cfg.CONF.QUARK.environment_capabilities
        cfg.CONF.set_override("environment_capabilities", override, "QUARK")
        cidr = "192.168.1.0/24"
        network = dict(id='1',
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1', ip_version=4, cidr=cidr, tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        try:
            with self._stubs(network, subnet_v4_info) as (net, sub_v4, update):
                port1 = port_api.create_port(self.context,
                                             self._make_body(net))
                self.assertIsNotNone(port1)

                sg_body = dict(tenant_id="derp",
                               name="test sg",
                               description="none")
                sg_body = dict(security_group=sg_body)

                sg = sg_api.create_security_group(self.context, sg_body)
                self.assertIsNotNone(sg)
                sgid = sg['id']
                self.assertIsNotNone(sgid)

                port_body = {'security_groups': [sgid]}
                port_body = dict(port=port_body)

                port1 = port_api.update_port(self.context, port1['id'],
                                             port_body)
                self.assertIsNotNone(port1)

                sgr_body = {
                    'protocol': 'tcp',
                    'security_group_id': sgid,
                    'tenant_id': "derp",
                    'direction': 'ingress'
                }
                sgr_body = dict(security_group_rule=sgr_body)
                sgr = sg_api.create_security_group_rule(self.context, sgr_body)
                self.assertIsNotNone(sgr)
                self.assertFalse(update.called)
        finally:
            cfg.CONF.set_override("environment_capabilities", old_override,
                                  "QUARK")
Exemplo n.º 17
0
    def test_env_caps_on_sg_async_update(self):
        """This test ensures that envcaps on works as designed."""
        env_set = [
            env.Capabilities.SECURITY_GROUPS,
            env.Capabilities.TENANT_NETWORK_SG,
            env.Capabilities.EGRESS,
            env.Capabilities.SG_UPDATE_ASYNC
        ]
        override = ','.join(env_set)
        old_override = cfg.CONF.QUARK.environment_capabilities
        cfg.CONF.set_override("environment_capabilities",
                              override,
                              "QUARK")
        cidr = "192.168.1.0/24"
        network = dict(id='1', name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1', ip_version=4, cidr=cidr,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        try:
            with self._stubs(network, subnet_v4_info) as (net, sub_v4, update):
                port1 = port_api.create_port(
                    self.context, self._make_body(net))
                self.assertIsNotNone(port1)

                sg_body = dict(tenant_id="derp", name="test sg",
                               description="none")
                sg_body = dict(security_group=sg_body)

                sg = sg_api.create_security_group(self.context, sg_body)
                self.assertIsNotNone(sg)
                sgid = sg['id']
                self.assertIsNotNone(sgid)

                port_body = {'security_groups': [sgid]}
                port_body = dict(port=port_body)

                port1 = port_api.update_port(self.context, port1['id'],
                                             port_body)

                sgr_body = {'protocol': 'tcp', 'security_group_id': sgid,
                            'tenant_id': "derp",
                            'direction': 'ingress'}
                sgr_body = dict(security_group_rule=sgr_body)
                sgr = sg_api.create_security_group_rule(self.context, sgr_body)
                self.assertIsNotNone(sgr)
                self.assertTrue(update.called)
        finally:
            cfg.CONF.set_override("environment_capabilities",
                                  old_override,
                                  "QUARK")
Exemplo n.º 18
0
    def test_ports_pagination(self):
        cidr = "192.168.1.0/24"

        ip_network = netaddr.IPNetwork(cidr)

        network = dict(id="1", name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}

        subnet = dict(id="1", ip_version=4, next_auto_assign_ip=2,
                      cidr=cidr, first_ip=ip_network.first,
                      last_ip=ip_network.last, ip_policy=None,
                      tenant_id="fake")
        subnet_info = {"subnet": subnet}

        def _make_body():
            fix_ipv4 = dict(subnet_id=sub_ports[0]['id'])
            port_info = {"port": dict(fixed_ips=[fix_ipv4],
                                      network_id=net['id'])}
            return port_info

        ports_per_page = 1
        with self._stubs(network, subnet_info) as (
                net, sub_ports):
            port1 = port_api.create_port(self.context, _make_body())
            port2 = port_api.create_port(self.context, _make_body())
            res_ports = port_api.get_ports(self.context, ports_per_page,
                                           ['id'], None)
            self.assertEqual(len(res_ports), ports_per_page)
            res_ports = port_api.get_ports(self.context)
            self.assertNotEqual(len(res_ports), ports_per_page)
            # Note (Perkins): Testing for a default sort on created_at,
            # but created_at is not available, so check that mac addresses,
            # which are created sequentially, are ordered correctly.
            res_ports = port_api.get_ports(self.context, 2, ['mac_address'],
                                           None)
            self.assertTrue(res_ports[0]['mac_address'] <
                            res_ports[1]['mac_address'])
            self.assertTrue(port1['id'] == res_ports[0]['id'])
            self.assertTrue(port2['id'] == res_ports[1]['id'])
Exemplo n.º 19
0
    def test_port_created_with_forbidden_mac_range(self):
        cidr = "192.168.1.0/24"
        ip_network = netaddr.IPNetwork(cidr)
        network = dict(id='1',
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="ANY")
        network = {"network": network}
        subnet_v4 = dict(id='1',
                         ip_version=4,
                         next_auto_assign_ip=2,
                         cidr=cidr,
                         first_ip=ip_network.first,
                         last_ip=ip_network.last,
                         ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        def _make_body(use_forbidden_mac_range=False):
            fix_ipv4 = dict(subnet_id=sub_v4s[0]['id'])
            port_info = \
                {"port": dict(
                    fixed_ips=[fix_ipv4], network_id=net['id'],
                    use_forbidden_mac_range=use_forbidden_mac_range
                )}
            return port_info

        with self._stubs(network, [subnet_v4_info]) as (net, sub_v4s, sub_v6):
            admin_ctxt = self.context.elevated()

            port = port_api.create_port(
                admin_ctxt, _make_body(use_forbidden_mac_range=True))
            port_mac = port["mac_address"]

            self.assertTrue(port_mac.startswith("AA:BB:CC"))

            with self.assertRaises(q_exc.MacAddressGenerationFailure):
                port_api.create_port(admin_ctxt, _make_body())
Exemplo n.º 20
0
 def test_can_create_port_with_adv_svc(self):
     with self._stubs(self.net_info, self.sub_info) as (network, subnet):
         port_info = {
             'port': {
                 'network_id': network['id'],
                 'tenant_id': 'someoneelse'
             }
         }
         self.context.is_admin = True
         self.context.is_advsvc = True
         port_mod = port_api.create_port(self.context, port_info)
         self.assertIsNotNone(port_mod['id'])
         self.assertNotEqual(port_mod['tenant_id'], network['tenant_id'])
Exemplo n.º 21
0
 def _stubs(self, network_info, subnet_info, ports_info):
     self.ipam = quark.ipam.QuarkIpamANY()
     with mock.patch("neutron.common.rpc.get_notifier"), mock.patch("neutron.quota.QUOTAS.limit_check"):
         net = network_api.create_network(self.admin_context, network_info)
         mac = {"mac_address_range": dict(cidr="AA:BB:CC")}
         macrng_api.create_mac_address_range(self.admin_context, mac)
         subnet_info["subnet"]["network_id"] = net["id"]
         sub = subnet_api.create_subnet(self.context, subnet_info)
         ports = []
         for port_info in ports_info:
             port_info["port"]["network_id"] = net["id"]
             ports.append(port_api.create_port(self.context, port_info))
         yield net, sub, ports
Exemplo n.º 22
0
 def _stubs(self, network_info, subnet_info, ports_info):
     self.ipam = quark.ipam.QuarkIpamANY()
     with mock.patch("neutron.common.rpc.get_notifier"), \
             mock.patch("neutron.quota.QUOTAS.limit_check"):
         net = network_api.create_network(self.admin_context, network_info)
         mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
         macrng_api.create_mac_address_range(self.admin_context, mac)
         subnet_info['subnet']['network_id'] = net['id']
         sub = subnet_api.create_subnet(self.context, subnet_info)
         ports = []
         for port_info in ports_info:
             port_info['port']['network_id'] = net['id']
             ports.append(port_api.create_port(self.context, port_info))
         yield net, sub, ports
Exemplo n.º 23
0
 def _stubs(self, network_info, subnet_info, port_info):
     self.ipam = quark.ipam.QuarkIpamANY()
     with contextlib.nested(mock.patch("neutron.common.rpc.get_notifier"),
                            mock.patch("neutron.quota.QUOTAS.limit_check")):
         net = network_api.create_network(self.context, network_info)
         mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
         self.context.is_admin = True
         macrng_api.create_mac_address_range(self.context, mac)
         self.context.is_admin = False
         subnet_info['subnet']['network_id'] = net['id']
         port_info['port']['network_id'] = net['id']
         sub = subnet_api.create_subnet(self.context, subnet_info)
         port = port_api.create_port(self.context, port_info)
         yield net, sub, port
Exemplo n.º 24
0
    def test_port_created_should_satisfy_ipam_strategy(self):
        cidr = "192.168.1.0/24"
        cidr_v6 = "2001:db8::/32"
        ip_network = netaddr.IPNetwork(cidr)
        ipv6_network = netaddr.IPNetwork(cidr_v6)
        network = dict(id='1',
                       name="public",
                       tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="BOTH_REQUIRED")
        network = {"network": network}
        subnet_v4 = dict(id='1',
                         ip_version=4,
                         next_auto_assign_ip=2,
                         cidr=cidr,
                         first_ip=ip_network.first,
                         last_ip=ip_network.last,
                         ip_policy=None,
                         tenant_id="fake")
        subnet_v6 = dict(id='2',
                         ip_version=6,
                         next_auto_assign_ip=2,
                         cidr=cidr_v6,
                         first_ip=ipv6_network.first,
                         last_ip=ipv6_network.last,
                         ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}
        subnet_v6_info = {"subnet": subnet_v6}

        def _make_body(ipv4, ipv6):
            fix_ipv4 = dict(ip_address=ipv4, subnet_id=sub_v4['id'])
            fix_ipv6 = dict(ip_address=ipv6, subnet_id=sub_v6['id'])
            port_info = {
                "port": dict(fixed_ips=[fix_ipv4, fix_ipv6],
                             network_id=net['id'])
            }
            return port_info

        with self._stubs(network, subnet_v4_info,
                         subnet_v6_info) as (net, sub_v4, sub_v6):
            ipv4 = "192.168.1.50"
            ipv6 = "2001:db8::10"

            port = port_api.create_port(self.context, _make_body(ipv4, ipv6))
            port_ips = [ip["ip_address"] for ip in port["fixed_ips"]]

            for ip in [ipv4, ipv6]:
                self.assertTrue(ip in port_ips)
Exemplo n.º 25
0
 def _stubs(self, network_info, subnet_info, ports_info):
     self.ipam = quark.ipam.QuarkIpamANY()
     with contextlib.nested(mock.patch("neutron.common.rpc.get_notifier")):
         self.context.is_admin = True
         net = network_api.create_network(self.context, network_info)
         mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
         macrng_api.create_mac_address_range(self.context, mac)
         self.context.is_admin = False
         subnet_info['subnet']['network_id'] = net['id']
         sub = subnet_api.create_subnet(self.context, subnet_info)
         ports = []
         for port_info in ports_info:
             port_info['port']['network_id'] = net['id']
             ports.append(port_api.create_port(self.context, port_info))
         yield net, sub, ports
Exemplo n.º 26
0
 def _stubs(self, network_info, subnet_info, port_info):
     self.ipam = quark.ipam.QuarkIpamANY()
     with contextlib.nested(
             mock.patch("neutron.common.rpc.get_notifier"),
             mock.patch("neutron.quota.QUOTAS.limit_check")):
         net = network_api.create_network(self.context, network_info)
         mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
         self.context.is_admin = True
         macrng_api.create_mac_address_range(self.context, mac)
         self.context.is_admin = False
         subnet_info['subnet']['network_id'] = net['id']
         port_info['port']['network_id'] = net['id']
         sub = subnet_api.create_subnet(self.context, subnet_info)
         port = port_api.create_port(self.context, port_info)
         yield net, sub, port
Exemplo n.º 27
0
    def test_port_created_doesnt_satisfy_ipam_strategy_raises(self):
        cidr = "192.168.1.0/24"
        ip_network = netaddr.IPNetwork(cidr)
        network = dict(id=1, name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="BOTH_REQUIRED")
        network = {"network": network}
        subnet_v4 = dict(id=1, ip_version=4, next_auto_assign_ip=2,
                         cidr=cidr, first_ip=ip_network.first,
                         last_ip=ip_network.last, ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}

        def _make_body_only_v4(ip):
            fix_ip = dict(ip_address=ip, subnet_id=sub_v4['id'])
            port_info = {"port": dict(fixed_ips=[fix_ip],
                                      network_id=net['id'])}
            return port_info

        with self._stubs(network, subnet_v4_info) as (
                net, sub_v4, sub_v6):
            ip = "192.168.1.50"
            with self.assertRaises(q_exc.IpAddressGenerationFailure):
                port_api.create_port(self.context, _make_body_only_v4(ip))
Exemplo n.º 28
0
    def test_port_created_with_multiple_fixed_ips_some_only_with_subnet(self):
        cidr = "192.168.1.0/24"
        another_cidr = "192.168.2.0/24"
        cidr_v6 = "2001:db8::/32"
        ip_network = netaddr.IPNetwork(cidr)
        another_ip_network = netaddr.IPNetwork(another_cidr)
        ipv6_network = netaddr.IPNetwork(cidr_v6)
        network = dict(id=1, name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="BOTH_REQUIRED")
        network = {"network": network}
        subnet_v4 = dict(id=1, ip_version=4, next_auto_assign_ip=2,
                         cidr=cidr, first_ip=ip_network.first,
                         last_ip=ip_network.last, ip_policy=None,
                         tenant_id="fake")
        another_subnet_v4 = dict(id=2, ip_version=4, next_auto_assign_ip=2,
                                 cidr=another_cidr,
                                 first_ip=another_ip_network.first,
                                 last_ip=another_ip_network.last,
                                 ip_policy=None, tenant_id="fake")
        subnet_v6 = dict(id=3, ip_version=6, next_auto_assign_ip=2,
                         cidr=cidr_v6, first_ip=ipv6_network.first,
                         last_ip=ipv6_network.last, ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}
        another_subnet_v4_info = {"subnet": another_subnet_v4}
        subnet_v6_info = {"subnet": subnet_v6}

        def _make_body(ipv4, ipv6):
            fix_ipv4 = dict(ip_address=ipv4, subnet_id=sub_v4s[0]['id'])
            another_fix_ipv4 = dict(subnet_id=sub_v4s[1]['id'])
            fix_ipv6 = dict(ip_address=ipv6, subnet_id=sub_v6['id'])
            port_info = {"port": dict(fixed_ips=[fix_ipv4, another_fix_ipv4,
                                                 fix_ipv6],
                                      network_id=net['id'])}
            return port_info

        with self._stubs(network, [subnet_v4_info, another_subnet_v4_info],
                         subnet_v6_info) as (net, sub_v4s, sub_v6):
            ipv4 = "192.168.1.50"
            another_ipv4 = "192.168.2.1"
            ipv6 = "2001:db8::10"

            port = port_api.create_port(self.context, _make_body(ipv4, ipv6))
            port_ips = [ip["ip_address"] for ip in port["fixed_ips"]]

            for ip in [ipv4, another_ipv4, ipv6]:
                self.assertTrue(ip in port_ips)
Exemplo n.º 29
0
 def _stubs(self, network_info, subnet_info, ports_info):
     self.ipam = quark.ipam.QuarkIpamANY()
     with contextlib.nested(
             mock.patch("neutron.common.rpc.get_notifier")):
         self.context.is_admin = True
         net = network_api.create_network(self.context, network_info)
         mac = {'mac_address_range': dict(cidr="AA:BB:CC")}
         macrng_api.create_mac_address_range(self.context, mac)
         self.context.is_admin = False
         subnet_info['subnet']['network_id'] = net['id']
         sub = subnet_api.create_subnet(self.context, subnet_info)
         ports = []
         for port_info in ports_info:
             port_info['port']['network_id'] = net['id']
             ports.append(port_api.create_port(self.context, port_info))
         yield net, sub, ports
Exemplo n.º 30
0
 def test_create_port_single_fixed_ip(self):
     with self._stubs(self.net_info, self.sub_info) as (network, subnet):
         fixed_ips = [dict(subnet_id=subnet['id'], enabled=True,
                      ip_address="192.168.10.45")]
         port = dict(port=dict(network_id=network['id'],
                               tenant_id=self.context.tenant_id,
                               device_id=2,
                               fixed_ips=fixed_ips))
         expected = {'status': "ACTIVE",
                     'device_owner': None,
                     'network_id': network["id"],
                     'tenant_id': self.context.tenant_id,
                     'admin_state_up': True,
                     'fixed_ips': fixed_ips,
                     'device_id': 2}
         result = port_api.create_port(self.context, port)
         for key in expected.keys():
             self.assertEqual(result[key], expected[key],
                              "Mismatch on %s" % key)
Exemplo n.º 31
0
    def test_port_created_should_satisfy_ipam_strategy(self):
        cidr = "192.168.1.0/24"
        cidr_v6 = "2001:db8::/32"
        ip_network = netaddr.IPNetwork(cidr)
        ipv6_network = netaddr.IPNetwork(cidr_v6)
        network = dict(id='1', name="public", tenant_id="make",
                       network_plugin="BASE",
                       ipam_strategy="BOTH_REQUIRED")
        network = {"network": network}
        subnet_v4 = dict(id='1', ip_version=4, next_auto_assign_ip=2,
                         cidr=cidr, first_ip=ip_network.first,
                         last_ip=ip_network.last, ip_policy=None,
                         tenant_id="fake")
        subnet_v6 = dict(id='2', ip_version=6, next_auto_assign_ip=2,
                         cidr=cidr_v6, first_ip=ipv6_network.first,
                         last_ip=ipv6_network.last, ip_policy=None,
                         tenant_id="fake")
        subnet_v4_info = {"subnet": subnet_v4}
        subnet_v6_info = {"subnet": subnet_v6}

        def _make_body(ipv4, ipv6):
            fix_ipv4 = dict(ip_address=ipv4, subnet_id=sub_v4['id'])
            fix_ipv6 = dict(ip_address=ipv6, subnet_id=sub_v6['id'])
            port_info = {"port": dict(fixed_ips=[fix_ipv4, fix_ipv6],
                                      network_id=net['id'])}
            return port_info

        with self._stubs(network, subnet_v4_info, subnet_v6_info) as (
                net, sub_v4, sub_v6):
            ipv4 = "192.168.1.50"
            ipv6 = "2001:db8::10"

            port = port_api.create_port(self.context, _make_body(ipv4, ipv6))
            port_ips = [ip["ip_address"] for ip in port["fixed_ips"]]

            for ip in [ipv4, ipv6]:
                self.assertTrue(ip in port_ips)
Exemplo n.º 32
0
 def test_create_port_single_fixed_ip(self):
     with self._stubs(self.net_info, self.sub_info) as (network, subnet):
         fixed_ips = [
             dict(subnet_id=subnet['id'],
                  enabled=True,
                  ip_address="192.168.10.45")
         ]
         port = dict(port=dict(network_id=network['id'],
                               tenant_id=self.context.tenant_id,
                               device_id=2,
                               fixed_ips=fixed_ips))
         expected = {
             'status': "ACTIVE",
             'device_owner': None,
             'network_id': network["id"],
             'tenant_id': self.context.tenant_id,
             'admin_state_up': True,
             'fixed_ips': fixed_ips,
             'device_id': 2
         }
         result = port_api.create_port(self.context, port)
         for key in expected.keys():
             self.assertEqual(result[key], expected[key],
                              "Mismatch on %s" % key)
Exemplo n.º 33
0
    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)
Exemplo n.º 34
0
    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)
Exemplo n.º 35
0
 def create_port(self, context, port):
     return ports.create_port(context, port)
Exemplo n.º 36
0
 def create_port(self, context, port):
     self._fix_missing_tenant_id(context, port["port"])
     return ports.create_port(context, port)
Exemplo n.º 37
0
 def create_port(self, context, port):
     return ports.create_port(context, port)
Exemplo n.º 38
0
 def create_port(self, context, port):
     self._fix_missing_tenant_id(context, port["port"])
     return ports.create_port(context, port)