adds REST api for allocating all interfaces of an instance

Change-Id: I89c9b33f01af2a500879149f28d03c0aa2c17e6e

melange/db/sqlalchemy/migrate_repo/versions/001_base_schema.py

@@ -138,12 +138,11 @@ mac_addresses = Table('mac_addresses', meta,
 
 interfaces = Table('interfaces', meta,
         Column('id', String(36), primary_key=True, nullable=False),
-        Column('virtual_interface_id', String(36), nullable=False),
+        Column('vif_id_on_device', String(36)),
         Column('device_id', String(36)),
         Column('tenant_id', String(36)),
         Column('created_at', DateTime()),
-        Column('updated_at', DateTime()),
-        UniqueConstraint('virtual_interface_id'))
+        Column('updated_at', DateTime()))
 
 allowed_ips = Table('allowed_ips', meta,
         Column('id', String(36), primary_key=True, nullable=False),

melange/ipam/models.py

@@ -794,19 +794,20 @@ class Interface(ModelBase):
     @classmethod
     def find_or_configure(cls, virtual_interface_id=None, device_id=None,
                           tenant_id=None, mac_address=None):
-        interface = Interface.get_by(virtual_interface_id=virtual_interface_id,
+        interface = Interface.get_by(vif_id_on_device=virtual_interface_id,
                                      tenant_id=tenant_id)
         if interface:
             return interface
 
         return cls.create_and_configure(virtual_interface_id,
                                         device_id,
-                                        tenant_id, mac_address)
+                                        tenant_id,
+                                        mac_address)
 
     @classmethod
     def create_and_configure(cls, virtual_interface_id=None, device_id=None,
                              tenant_id=None, mac_address=None):
-        interface = Interface.create(virtual_interface_id=virtual_interface_id,
+        interface = Interface.create(vif_id_on_device=virtual_interface_id,
                                      device_id=device_id,
                                      tenant_id=tenant_id)
         if mac_address:
@@ -886,17 +887,29 @@ class Interface(ModelBase):
             return self.mac_address.eui_format
 
     def _validate(self):
-        self._validate_presence_of('virtual_interface_id', 'tenant_id')
+        self._validate_presence_of("tenant_id")
         self._validate_uniqueness_of_virtual_interface_id()
 
     def _validate_uniqueness_of_virtual_interface_id(self):
+        if self.vif_id_on_device is None:
+            return
         existing_interface = self.get_by(
-            virtual_interface_id=self.virtual_interface_id)
+            vif_id_on_device=self.vif_id_on_device)
         if existing_interface and self != existing_interface:
             msg = ("Virtual Interface %s already exists")
             self._add_error('virtual_interface_id',
                             msg % self.virtual_interface_id)
 
+    @property
+    def virtual_interface_id(self):
+        return self.vif_id_on_device or self.id
+
+    @classmethod
+    def delete_by(self, **kwargs):
+        ifaces = Interface.find_all(**kwargs)
+        for iface in ifaces:
+            iface.delete()
+
 
 class Policy(ModelBase):
 

melange/ipam/service.py

@@ -384,12 +384,12 @@ class InterfaceIpAllocationsController(BaseController):
 
     def bulk_delete(self, request, network_id, interface_id, tenant_id):
         network = models.Network.find_by(id=network_id, tenant_id=tenant_id)
-        interface = models.Interface.find_by(virtual_interface_id=interface_id)
+        interface = models.Interface.find_by(vif_id_on_device=interface_id)
         network.deallocate_ips(interface_id=interface.id)
 
     def index(self, request, network_id, interface_id, tenant_id):
         network = models.Network.find_by(id=network_id, tenant_id=tenant_id)
-        interface = models.Interface.find_by(virtual_interface_id=interface_id)
+        interface = models.Interface.find_by(vif_id_on_device=interface_id)
         ips_on_interface = network.allocated_ips(interface_id=interface.id)
         ip_configuration_view = views.IpConfigurationView(*ips_on_interface)
         return dict(ip_addresses=ip_configuration_view.data())
@@ -416,10 +416,51 @@ class InterfacesController(BaseController, ShowAction, DeleteAction):
 
     def show(self, request, virtual_interface_id, tenant_id=None):
         interface = models.Interface.find_by(
-                virtual_interface_id=virtual_interface_id, tenant_id=tenant_id)
+                vif_id_on_device=virtual_interface_id,
+                tenant_id=tenant_id)
         view_data = views.InterfaceConfigurationView(interface).data()
         return dict(interface=view_data)
 
+    def delete(self, request, **kwargs):
+        kwargs['vif_id_on_device'] = kwargs.pop('virtual_interface_id', None)
+        self._model.find_by(**kwargs).delete()
+
+
+class InstanceInterfacesController(BaseController):
+
+    def update(self, request, device_id, body=None):
+        models.Interface.delete_by(device_id=device_id)
+
+        params = self._extract_required_params(body, 'instance')
+        tenant_id = params['tenant_id']
+        created_interfaces = []
+        for iface in params['interfaces']:
+
+            network_params = utils.stringify_keys(iface.pop('network', None))
+            interface = models.Interface.create_and_configure(
+                    device_id=device_id, tenant_id=tenant_id, **iface)
+
+            if network_params:
+                network = models.Network.find_or_create_by(
+                            network_params.pop('id'),
+                            network_params.pop('tenant_id'))
+                network.allocate_ips(interface=interface, **network_params)
+
+            view_data = views.InterfaceConfigurationView(interface).data()
+            created_interfaces.append(view_data)
+
+        return {'instance': {'interfaces': created_interfaces}}
+
+    def show(self, request, device_id):
+        interfaces = models.Interface.find_all(device_id=device_id)
+        view_data = [views.InterfaceConfigurationView(iface).data()
+                        for iface in interfaces]
+
+        return {'instance': {'interfaces': view_data}}
+
+    def delete(self, request, device_id):
+        models.Interface.delete_by(device_id=device_id)
+
 
 class MacAddressRangesController(BaseController, ShowAction, DeleteAction):
 
@@ -438,14 +479,16 @@ class MacAddressRangesController(BaseController, ShowAction, DeleteAction):
 class InterfaceAllowedIpsController(BaseController):
 
     def index(self, request, interface_id, tenant_id):
-        interface = models.Interface.find_by(virtual_interface_id=interface_id,
-                                             tenant_id=tenant_id)
+        interface = models.Interface.find_by(
+                        vif_id_on_device=interface_id,
+                        tenant_id=tenant_id)
         return dict(ip_addresses=[ip.data() for ip in interface.ips_allowed()])
 
     def create(self, request, interface_id, tenant_id, body=None):
         params = self._extract_required_params(body, 'allowed_ip')
         interface = models.Interface.find_by(
-            virtual_interface_id=interface_id, tenant_id=tenant_id)
+                        vif_id_on_device=interface_id,
+                        tenant_id=tenant_id)
         network = models.Network.find_by(id=params['network_id'])
         ip = network.find_allocated_ip(address=params['ip_address'],
                                        used_by_tenant_id=tenant_id)
@@ -454,13 +497,14 @@ class InterfaceAllowedIpsController(BaseController):
 
     def show(self, request, interface_id, tenant_id, address):
         interface = models.Interface.find_by(
-            virtual_interface_id=interface_id, tenant_id=tenant_id)
+                        vif_id_on_device=interface_id,
+                        tenant_id=tenant_id)
         ip = interface.find_allowed_ip(address)
         return dict(ip_address=ip.data())
 
     def delete(self, request, interface_id, tenant_id, address):
         interface = models.Interface.find_by(
-            virtual_interface_id=interface_id, tenant_id=tenant_id)
+            vif_id_on_device=interface_id, tenant_id=tenant_id)
         ip = interface.find_allowed_ip(address)
         interface.disallow_ip(ip)
 
@@ -483,6 +527,7 @@ class API(wsgi.Router):
         self._allocated_ips_mapper(mapper)
         self._ip_routes_mapper(mapper)
         self._interface_mapper(mapper)
+        self._instance_interface_mapper(mapper)
         self._mac_address_range_mapper(mapper)
 
     def _allocated_ips_mapper(self, mapper):
@@ -537,6 +582,24 @@ class API(wsgi.Router):
                         path_prefix=("/ipam/tenants/{tenant_id}/"
                                      "interfaces/{interface_id}"))
 
+    def _instance_interface_mapper(self, mapper):
+        res = InstanceInterfacesController().create_resource()
+        self._connect(mapper,
+                      "/ipam/instances/{device_id}/interfaces",
+                      controller=res,
+                      action="update",
+                      conditions=dict(method=['PUT']))
+        self._connect(mapper,
+                      "/ipam/instances/{device_id}/interfaces",
+                      controller=res,
+                      action="show",
+                      conditions=dict(method=['GET']))
+        self._connect(mapper,
+                      "/ipam/instances/{device_id}/interfaces",
+                      controller=res,
+                      action="delete",
+                      conditions=dict(method=['DELETE']))
+
     def _mac_address_range_mapper(self, mapper):
         range_res = MacAddressRangesController().create_resource()
         path = ("/ipam/mac_address_ranges")

melange/tests/factories/models.py

@@ -90,7 +90,7 @@ class PolicyFactory(factory.Factory):
 
 class InterfaceFactory(factory.Factory):
     FACTORY_FOR = models.Interface
-    virtual_interface_id = factory.LazyAttribute(lambda a:
+    vif_id_on_device = factory.LazyAttribute(lambda a:
                                                  utils.generate_uuid())
     device_id = "instance_id"
     tenant_id = "RAX"

melange/tests/unit/test_ipam_models.py

@@ -657,7 +657,7 @@ class TestIpBlock(tests.BaseTest):
         net2_block = factory_models.IpBlockFactory(network_id="2")
 
         expected_error_msg = ("Interface %s is configured on another network"
-                              % iface_with_net1.virtual_interface_id)
+                              % iface_with_net1.vif_id_on_device)
 
         self.assertRaisesExcMessage(models.IpAllocationNotAllowedError,
                                     expected_error_msg,
@@ -1256,7 +1256,7 @@ class TestIpAddress(tests.BaseTest):
         self.assertEqual(data['version'], ip.version)
         self.assertEqual(data['used_by_tenant'], interface.tenant_id)
         self.assertEqual(data['used_by_device'], interface.device_id)
-        self.assertEqual(data['interface_id'], interface.virtual_interface_id)
+        self.assertEqual(data['interface_id'], interface.vif_id_on_device)
         self.assertEqual(data['created_at'], ip.created_at)
         self.assertEqual(data['updated_at'], ip.updated_at)
 
@@ -1314,14 +1314,14 @@ class TestIpAddress(tests.BaseTest):
         self.assertEqual(ipv6.version, 6)
 
     def test_retrieves_interface(self):
-        interface = factory_models.InterfaceFactory(virtual_interface_id="112")
+        interface = factory_models.InterfaceFactory(vif_id_on_device="112")
         ip = factory_models.IpAddressFactory(interface_id=interface.id)
 
         self.assertEqual(ip.interface, interface)
         self.assertEqual(ip.interface.virtual_interface_id, "112")
 
-    def test_virtual_interface_id(self):
-        interface = factory_models.InterfaceFactory(virtual_interface_id="112")
+    def test_vif_id_on_device(self):
+        interface = factory_models.InterfaceFactory(vif_id_on_device="112")
         ip = factory_models.IpAddressFactory(interface_id=interface.id)
 
         self.assertEqual(ip.virtual_interface_id, "112")
@@ -2195,7 +2195,7 @@ class TestInterface(tests.BaseTest):
 
     def test_find_or_configure_finds_existing_interface(self):
         existing_interface = factory_models.InterfaceFactory(
-            virtual_interface_id="11234",
+            vif_id_on_device="11234",
             device_id="huge_instance",
             tenant_id="tnt")
 
@@ -2208,7 +2208,7 @@ class TestInterface(tests.BaseTest):
 
     def test_find_or_configure_finds_without_device_id(self):
         existing_interface = factory_models.InterfaceFactory(
-            virtual_interface_id="11234",
+            vif_id_on_device="11234",
             device_id="huge_instance",
             tenant_id="tnt")
 
@@ -2220,7 +2220,7 @@ class TestInterface(tests.BaseTest):
 
     def test_find_or_configure_fails_if_vif_exists_for_another_tenant(self):
         existing_interface = factory_models.InterfaceFactory(
-            virtual_interface_id="vif", device_id="device", tenant_id="tnt1")
+            vif_id_on_device="vif", device_id="device", tenant_id="tnt1")
 
         self.assertRaises(models.InvalidModelError,
                           models.Interface.find_or_configure,
@@ -2236,7 +2236,7 @@ class TestInterface(tests.BaseTest):
 
         created_interface = models.Interface.find_by(id=interface.id)
         self.assertEqual(interface, created_interface)
-        self.assertEqual(created_interface.virtual_interface_id,
+        self.assertEqual(created_interface.vif_id_on_device,
                          "new_interface")
         self.assertEqual(created_interface.device_id, "huge_instance")
         self.assertEqual(created_interface.tenant_id, "tenant")
@@ -2270,19 +2270,11 @@ class TestInterface(tests.BaseTest):
 
         self.assertIsNone(models.MacAddress.get_by(interface_id=interface.id))
 
-    def test_validate_presence_of_virtual_interface_id(self):
-        interface = factory_models.InterfaceFactory.build(
-            virtual_interface_id=None)
-
-        self.assertFalse(interface.is_valid())
-        self.assertEqual(interface.errors['virtual_interface_id'],
-                         ["virtual_interface_id should be present"])
-
     def test_validate_virtual_interface_id_is_unique(self):
-        factory_models.InterfaceFactory(virtual_interface_id="iface_id")
+        factory_models.InterfaceFactory(vif_id_on_device="iface_id")
 
         dup_iface = factory_models.InterfaceFactory.build(
-            virtual_interface_id="iface_id")
+            vif_id_on_device="iface_id")
 
         self.assertFalse(dup_iface.is_valid())
         self.assertEqual(dup_iface.errors['virtual_interface_id'],
@@ -2374,6 +2366,21 @@ class TestInterface(tests.BaseTest):
 
         self.assertEqual(interface.plugged_in_network_id(), "net1")
 
+    def test_delete_by(self):
+        interface1 = factory_models.InterfaceFactory(device_id="instance1")
+        net1_block = factory_models.IpBlockFactory(network_id="net1")
+        iface1_ip = net1_block.allocate_ip(interface1)
+        interface2 = factory_models.InterfaceFactory(device_id="instance1")
+        interface3 = factory_models.InterfaceFactory(device_id="instance1")
+        noise_interface = factory_models.InterfaceFactory(device_id="ins")
+
+        models.Interface.delete_by(device_id="instance1")
+
+        [self.assertIsNone(models.Interface.get(iface.id)) for iface in
+                    [interface1, interface2, interface3]]
+        self.assertTrue(models.IpAddress.get(
+                                iface1_ip.id).marked_for_deallocation)
+
 
 class TestAllowedIp(tests.BaseTest):
 
@@ -2504,7 +2511,7 @@ class TestAllowedIp(tests.BaseTest):
 
     def test_find_allowed_ip_raises_model_not_found(self):
         interface = factory_models.InterfaceFactory(
-            virtual_interface_id="vif_1")
+            vif_id_on_device="vif_1")
         self._plug_interface_into_network("AAA", interface)
         ip1 = self._ip_on_network("AAA")
         ip2 = self._ip_on_network("AAA")
@@ -2520,7 +2527,7 @@ class TestAllowedIp(tests.BaseTest):
 
     def test_cannot_allow_ip_when_interface_is_pluged_into_other_network(self):
         interface_plugged_into_net1 = factory_models.InterfaceFactory(
-            virtual_interface_id="viffy")
+            vif_id_on_device="viffy")
         net1_block = factory_models.IpBlockFactory(network_id="1")
         net1_ip = net1_block.allocate_ip(interface_plugged_into_net1)
         net2_block = factory_models.IpBlockFactory(network_id="2")
@@ -2536,7 +2543,7 @@ class TestAllowedIp(tests.BaseTest):
 
     def test_cannot_allow_ip_if_interface_isnt_plugged_into_any_network(self):
         unplugged_interface = factory_models.InterfaceFactory(
-            virtual_interface_id="vif_id")
+            vif_id_on_device="vif_id")
         ip = factory_models.IpAddressFactory()
 
         err_msg = ("Ip %s cannot be allowed on interface vif_id "

melange/tests/unit/test_ipam_service.py

@@ -497,7 +497,7 @@ class TestIpAddressController(ControllerTestBase):
                                }
                             })
 
-        interface = models.Interface.find_by(virtual_interface_id="vif_id")
+        interface = models.Interface.find_by(vif_id_on_device="vif_id")
         self.assertEqual(interface.tenant_id, "RAX")
 
     def test_create_defaults_interface_owner_to_block_owner(self):
@@ -509,7 +509,7 @@ class TestIpAddressController(ControllerTestBase):
                                }
                             })
 
-        interface = models.Interface.find_by(virtual_interface_id="vif_id")
+        interface = models.Interface.find_by(vif_id_on_device="vif_id")
         self.assertEqual(interface.tenant_id, block.tenant_id)
 
     def test_create_given_the_device_using_the_ip(self):
@@ -576,7 +576,7 @@ class TestIpAddressController(ControllerTestBase):
             cidr="BC:AD:CE:0:0:0/40")
         block = factory_models.IpBlockFactory(cidr="10.0.0.0/24")
         iface = factory_models.InterfaceFactory(
-            virtual_interface_id="iface_id")
+            vif_id_on_device="iface_id")
         mac_range.allocate_mac(interface_id=iface.id)
 
         response = self.app.post_json(self._address_path(block),
@@ -1972,7 +1972,7 @@ class TestInterfaceIpAllocationsController(ControllerTestBase):
         path = "/ipam/tenants/tnt_id/networks/1/interfaces/123/ip_allocations"
         response = self.app.post_json(path)
 
-        interface = models.Interface.find_by(virtual_interface_id="123")
+        interface = models.Interface.find_by(vif_id_on_device="123")
 
         self.assertEqual(response.status_int, 201)
         self.assertEqual(interface.tenant_id, "tnt_id")
@@ -2068,7 +2068,7 @@ class TestInterfaceIpAllocationsController(ControllerTestBase):
         ip_block = factory_models.PrivateIpBlockFactory(tenant_id="tnt_id",
                                                         network_id="1")
 
-        interface = factory_models.InterfaceFactory(virtual_interface_id="123")
+        interface = factory_models.InterfaceFactory(vif_id_on_device="123")
         ip = ip_block.allocate_ip(interface=interface)
 
         response = self.app.delete("/ipam/tenants/tnt_id/networks/1/"
@@ -2093,7 +2093,7 @@ class TestInterfaceIpAllocationsController(ControllerTestBase):
         ipv6_block = factory(cidr="fe::/96",
                              network_id="1",
                              tenant_id="tnt_id")
-        iface = factory_models.InterfaceFactory(virtual_interface_id="123")
+        iface = factory_models.InterfaceFactory(vif_id_on_device="123")
         models.MacAddress.create(interface_id=iface.id,
                                  address="aa:bb:cc:dd:ee:ff")
 
@@ -2122,7 +2122,7 @@ class TestInterfacesController(ControllerTestBase):
 
         self.assertEqual(response.status_int, 201)
         created_interface = models.Interface.find_by(
-            virtual_interface_id='virt_iface')
+            vif_id_on_device='virt_iface')
 
         self.assertEqual(created_interface.device_id, 'instance')
         self.assertEqual(created_interface.tenant_id, 'tnt')
@@ -2149,7 +2149,7 @@ class TestInterfacesController(ControllerTestBase):
         ip_address = models.IpAddress.find_by(ip_block_id=ip_block.id,
                                               address="10.0.0.2")
         created_interface = models.Interface.find_by(
-            virtual_interface_id="virt_iface")
+            vif_id_on_device="virt_iface")
         self.assertEqual(ip_address.interface_id, created_interface.id)
 
     def test_create_interface_allocates_mac(self):
@@ -2163,7 +2163,7 @@ class TestInterfacesController(ControllerTestBase):
                             })
 
         created_interface = models.Interface.find_by(
-            virtual_interface_id='virt_iface')
+            vif_id_on_device='virt_iface')
         allocated_mac = models.MacAddress.get_by(
             interface_id=created_interface.id)
         self.assertIsNotNone(allocated_mac)
@@ -2183,7 +2183,7 @@ class TestInterfacesController(ControllerTestBase):
                             })
 
         created_interface = models.Interface.find_by(
-            virtual_interface_id='virt_iface')
+            vif_id_on_device='virt_iface')
 
         allocated_ip = models.IpAddress.find_by(ip_block_id=block.id)
         self.assertEquals(allocated_ip.interface_id, created_interface.id)
@@ -2215,7 +2215,7 @@ class TestInterfacesController(ControllerTestBase):
                             })
 
         created_interface = models.Interface.find_by(
-            virtual_interface_id='virt_iface')
+            vif_id_on_device='virt_iface')
 
         ipv6_address = models.IpAddress.find_by(ip_block_id=ipv6_block.id)
         self.assertEquals(ipv6_address.interface_id, created_interface.id)
@@ -2231,7 +2231,7 @@ class TestInterfacesController(ControllerTestBase):
                                    }
                                 })
 
-        interface = models.Interface.find_by(virtual_interface_id='virt_iface')
+        interface = models.Interface.find_by(vif_id_on_device='virt_iface')
         created_block = models.IpAddress.find_by(
             interface_id=interface.id).ip_block
         self.assertEqual(created_block.network_id, "net1")
@@ -2245,7 +2245,7 @@ class TestInterfacesController(ControllerTestBase):
         ip_block2 = factory_models.PrivateIpBlockFactory(tenant_id="tnt_id",
                                                          network_id="1")
         mac_range = factory_models.MacAddressRangeFactory()
-        interface = factory_models.InterfaceFactory(virtual_interface_id="123")
+        interface = factory_models.InterfaceFactory(vif_id_on_device="123")
         mac = mac_range.allocate_mac(interface_id=interface.id)
         ip1 = ip_block1.allocate_ip(interface=interface)
         ip2 = ip_block2.allocate_ip(interface=interface)
@@ -2259,7 +2259,7 @@ class TestInterfacesController(ControllerTestBase):
 
     def test_show_returns_allocated_ips(self):
         iface = factory_models.InterfaceFactory(tenant_id="tnt_id",
-                                                virtual_interface_id="vif_id")
+                                                vif_id_on_device="vif_id")
         mac = models.MacAddress.create(address="ab:bc:cd:12:23:34",
                                        interface_id=iface.id)
         ip1 = factory_models.IpAddressFactory(interface_id=iface.id)
@@ -2277,6 +2277,96 @@ class TestInterfacesController(ControllerTestBase):
                          views.IpConfigurationView(*iface.ip_addresses).data())
 
 
+class TestInstanceInterfacesController(ControllerTestBase):
+
+    def test_update_creates_interfaces(self):
+        net_ids = ["net_id_1", "net_id_2", "net_id_3"]
+        for net_id in net_ids:
+            factory_models.PrivateIpBlockFactory(tenant_id="RAX",
+                                                 network_id=net_id)
+        put_data = {'instance': {
+            'tenant_id': "tnt",
+            'interfaces': [
+                {'network': {'id': net_ids[0], 'tenant_id':"RAX"}},
+                {'network': {'id': net_ids[1], 'tenant_id':"RAX"}},
+                {'network': {'id': net_ids[2], 'tenant_id':"RAX"}},
+                ]},
+            }
+
+        response = self.app.put_json("/ipam/instances/instance_id/interfaces",
+                                     put_data)
+        self.assertEqual(response.status_int, 200)
+        ifaces = sorted(models.Interface.find_all(device_id='instance_id'),
+                        key=lambda iface: iface.plugged_in_network_id())
+        self.assertItemsEqual([self._get_iface_data(iface)
+                               for iface in ifaces],
+                              response.json['instance']['interfaces'])
+        for iface, network_id in zip(ifaces, net_ids):
+            self.assertEqual('instance_id', iface.device_id)
+            self.assertEqual('tnt', iface.tenant_id)
+            self.assertEqual(network_id, iface.plugged_in_network_id())
+
+    def test_update_deletes_existing_interface(self):
+        provider_block = factory_models.IpBlockFactory(tenant_id="RAX",
+                                                       network_id="net_id")
+        previous_ip = self._setup_interface_and_ip("instance_id",
+                                                   "tenant",
+                                                   provider_block)
+        put_data = {'instance': {
+            'tenant_id': "tenant",
+            'interfaces': [{'network': {'id': 'net_id', 'tenant_id':"RAX"}}]}}
+
+        response = self.app.put_json("/ipam/instances/instance_id/interfaces",
+                                     put_data)
+
+        self.assertTrue(models.IpAddress.get(
+                        previous_ip.id).marked_for_deallocation)
+
+    def test_get_interfaces(self):
+        provider_block = factory_models.IpBlockFactory(tenant_id="RAX",
+                                                       network_id="net_id")
+        self._setup_interface_and_ip("instance_id",
+                                     "tenant",
+                                     provider_block)
+
+        response = self.app.get("/ipam/instances/instance_id/interfaces")
+
+        iface = models.Interface.find_by(device_id="instance_id")
+        self.assertEqual([self._get_iface_data(iface)],
+                         response.json['instance']['interfaces'])
+
+    def test_delete_interfaces(self):
+        provider_block = factory_models.IpBlockFactory(tenant_id="RAX",
+                                                       network_id="net_id")
+        self._setup_interface_and_ip("instance_id",
+                                     "tenant",
+                                     provider_block)
+        self._setup_interface_and_ip("instance_id",
+                                     "tenant",
+                                     provider_block)
+        noise_iface = self._setup_interface_and_ip("other_instance",
+                                                   "tenant",
+                                                   provider_block)
+
+        self.app.delete("/ipam/instances/instance_id/interfaces")
+
+        deleted_instance_ifaces = models.Interface.get_by(
+                device_id="instance_id")
+        existing_instance_ifaces = models.Interface.get_by(
+                device_id="other_instance")
+
+        self.assertIsNone(deleted_instance_ifaces)
+        self.assertIsNotNone(existing_instance_ifaces)
+
+    def _get_iface_data(self, iface):
+        return unit.sanitize(views.InterfaceConfigurationView(iface).data())
+
+    def _setup_interface_and_ip(self, device_id, tenant_of_device, block):
+        iface = factory_models.InterfaceFactory(device_id=device_id,
+                                                tenant_id=tenant_of_device)
+        return _allocate_ip(block, interface=iface)
+
+
 class TestMacAddressRangesController(ControllerTestBase):
 
     def test_create(self):
@@ -2335,7 +2425,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_index(self):
         interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         ip_factory = factory_models.IpAddressFactory
         block_factory = factory_models.IpBlockFactory
         ip_on_interface = block_factory(network_id="1").allocate_ip(interface)
@@ -2355,7 +2445,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_index_returns_404_when_interface_doesnt_exist(self):
         noise_interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         response = self.app.get(
             "/ipam/tenants/tnt_id/interfaces/bad_vif_id/allowed_ips",
             status="*")
@@ -2366,7 +2456,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_index_return_404_when_interface_doesnt_belong_to_tenant(self):
         interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         response = self.app.get(
             "/ipam/tenants/bad_tnt_id/interfaces/vif_id/allowed_ips",
             status="*")
@@ -2377,7 +2467,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_create(self):
         interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         block = factory_models.IpBlockFactory(network_id="net123")
         ip_on_interface = block.allocate_ip(interface)
 
@@ -2395,7 +2485,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_create_raises_404_when_interface_doesnt_exist(self):
         noise_interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         block = factory_models.IpBlockFactory(network_id="net123")
         ip = block.allocate_ip(factory_models.InterfaceFactory(
             tenant_id="tnt_id"))
@@ -2412,7 +2502,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_create_raises_404_when_ip_is_not_of_the_same_tenant(self):
         interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         block = factory_models.IpBlockFactory(network_id="net123")
         other_tenants_ip = block.allocate_ip(factory_models.InterfaceFactory(
             tenant_id="blah"))
@@ -2431,7 +2521,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_delete(self):
         interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         block = factory_models.IpBlockFactory(network_id="net123")
         ip_on_interface = block.allocate_ip(interface)
         allowed_ip = block.allocate_ip(factory_models.InterfaceFactory())
@@ -2443,7 +2533,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_delete_fails_for_non_existent_interface(self):
         noise_interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
 
         response = self.app.delete("/ipam/tenants/tnt_id/interfaces/"
                                    "bad_iface_id/allowed_ips/10.1.1.1",
@@ -2455,7 +2545,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_delete_fails_when_allowed_ip_doesnt_exist(self):
         factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
 
         response = self.app.delete("/ipam/tenants/tnt_id/interfaces/"
                                    "vif_id/allowed_ips/10.1.1.1",
@@ -2468,7 +2558,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_show(self):
         interface = factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
         block = factory_models.IpBlockFactory(network_id="net123")
         ip_on_interface = block.allocate_ip(interface)
         allowed_ip = block.allocate_ip(factory_models.InterfaceFactory())
@@ -2482,7 +2572,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_show_raises_404_when_allowed_address_doesnt_exist(self):
         factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
 
         response = self.app.get("/ipam/tenants/tnt_id/interfaces/vif_id/"
                                 "allowed_ips/10.1.1.1", status="*")
@@ -2494,7 +2584,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_show_raises_404_when_interface_belongs_to_other_tenant(self):
         factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
 
         response = self.app.get("/ipam/tenants/bad_tnt_id/interfaces/vif_id/"
                                 "allowed_ips/10.1.1.1", status="*")
@@ -2505,7 +2595,7 @@ class TestInterfaceAllowedIpsController(ControllerTestBase):
 
     def test_show_raises_404_when_interface_doesnt_exist(self):
         factory_models.InterfaceFactory(
-            tenant_id="tnt_id", virtual_interface_id="vif_id")
+            tenant_id="tnt_id", vif_id_on_device="vif_id")
 
         response = self.app.get("/ipam/tenants/tnt_id/interfaces/bad_vif_id/"
                                 "allowed_ips/10.1.1.1", status="*")

melange/tests/unit/test_ipam_views.py

@@ -26,7 +26,7 @@ class TestIpConfigurationView(tests.BaseTest):
     def test_data_returns_block_ip_info(self):
         block1 = factory_models.IpBlockFactory()
         block2 = factory_models.IpBlockFactory()
-        interface = factory_models.InterfaceFactory(virtual_interface_id="123")
+        interface = factory_models.InterfaceFactory(vif_id_on_device="123")
         ip1 = factory_models.IpAddressFactory(ip_block_id=block1.id,
                                               interface_id=interface.id)
         ip2 = factory_models.IpAddressFactory(ip_block_id=block2.id,
@@ -41,7 +41,7 @@ class TestIpConfigurationView(tests.BaseTest):
 
     def test_data_returns_deallocated_ip_info(self):
         block = factory_models.IpBlockFactory()
-        interface = factory_models.InterfaceFactory(virtual_interface_id="123")
+        interface = factory_models.InterfaceFactory(vif_id_on_device="123")
         ip = factory_models.IpAddressFactory(ip_block_id=block.id,
                                               interface_id=interface.id)
         ip.deallocate()
@@ -53,7 +53,7 @@ class TestIpConfigurationView(tests.BaseTest):
 
     def test_data_returns_route_info(self):
         block = factory_models.IpBlockFactory()
-        interface = factory_models.InterfaceFactory(virtual_interface_id="123")
+        interface = factory_models.InterfaceFactory(vif_id_on_device="123")
         route1 = factory_models.IpRouteFactory(source_block_id=block.id)
         route2 = factory_models.IpRouteFactory(source_block_id=block.id)
         ip = factory_models.IpAddressFactory(ip_block_id=block.id,