Refactor of network

Removed the /network/floating/<pool> routes to only have /network/fixed
and /network/public. This allows for faster build of the compute
objects and does not remove relevant information to the user since
the pools cannot be controlled from OCCI anyway.

Change-Id: Ida9f3b3e1db676f13824b0de83639a23846058dc

ooi/api/compute.py

@@ -30,15 +30,12 @@ from ooi.openstack import network as os_network
 from ooi.openstack import templates
 
 
-def _create_network_link(addr, comp, floating_ips):
+def _create_network_link(addr, comp):
     if addr["OS-EXT-IPS:type"] == "floating":
-        for ip in floating_ips:
+        net_id = network_api.FLOATING_PREFIX
-            if addr["addr"] == ip["ip"]:
-                net = network.NetworkResource(
-                    title="network",
-                    id="%s/%s" % (network_api.FLOATING_PREFIX, ip["pool"]))
     else:
-        net = network.NetworkResource(title="network", id="fixed")
+        net_id = network_api.FIXED_PREFIX
+    net = network.NetworkResource(title="network", id=net_id)
     return os_network.OSNetworkInterface(comp, net,
                                          addr["OS-EXT-IPS-MAC:mac_addr"],
                                          addr["addr"])
@@ -173,11 +170,9 @@ class Controller(ooi.api.base.Controller):
         # network links
         addresses = s.get("addresses", {})
         if addresses:
-            floating_ips = self.os_helper.get_floating_ips(req)
             for addr_set in addresses.values():
                 for addr in addr_set:
-                    comp.add_link(_create_network_link(addr, comp,
+                    comp.add_link(_create_network_link(addr, comp))
-                                                       floating_ips))
 
         return [comp]
 

ooi/api/network.py

@@ -21,6 +21,7 @@ from ooi.occi.core import collection
 from ooi.occi.infrastructure import network
 
 FLOATING_PREFIX = "floating"
+FIXED_PREFIX = "fixed"
 
 
 def _build_network(name, prefix=None):
@@ -44,29 +45,21 @@ class Controller(base.Controller):
 
     def _floating_index(self, req):
         pools = self.os_helper.get_floating_ip_pools(req)
-
         occi_network_resources = []
-        for p in pools:
+        if pools:
-            occi_network_resources.append(_build_network(p["name"],
+            occi_network_resources.append(_build_network(FLOATING_PREFIX))
-                                                         FLOATING_PREFIX))
         return occi_network_resources
 
-    def general_index(self, req):
-        occi_network_resources = self._floating_index(req)
-        occi_network_resources.append(_build_network("fixed"))
-        return collection.Collection(resources=occi_network_resources)
-
     def index(self, req):
         occi_network_resources = self._floating_index(req)
+        occi_network_resources.append(_build_network(FIXED_PREFIX))
         return collection.Collection(resources=occi_network_resources)
 
-    def show_fixed(self, req):
-        return _build_network("fixed")
-
     def show(self, req, id):
-        pools = self.os_helper.get_floating_ip_pools(req)
+        if id == FIXED_PREFIX:
-
+            return [_build_network(id)]
-        for p in pools:
+        elif id == FLOATING_PREFIX:
-            if p['name'] == id:
+            pools = self.os_helper.get_floating_ip_pools(req)
-                return [_build_network(p["name"], FLOATING_PREFIX)]
+            if pools:
+                return [_build_network(id)]
         raise exception.NetworkNotFound(resource_id=id)

ooi/tests/controllers/test_compute.py

@@ -126,12 +126,11 @@ class TestComputeController(base.TestController):
             self.assertEqual([], ret)
             m_run_action.assert_called_with(mock.ANY, action, server_uuid)
 
-    @mock.patch.object(helpers.OpenStackHelper, "get_floating_ips")
     @mock.patch.object(helpers.OpenStackHelper, "get_server_volumes_link")
     @mock.patch.object(helpers.OpenStackHelper, "get_image")
     @mock.patch.object(helpers.OpenStackHelper, "get_flavor")
     @mock.patch.object(helpers.OpenStackHelper, "get_server")
-    def test_show(self, m_server, m_flavor, m_image, m_vol, m_ips):
+    def test_show(self, m_server, m_flavor, m_image, m_vol):
         for tenant in fakes.tenants.values():
             servers = fakes.servers[tenant["id"]]
             for server in servers:
@@ -140,13 +139,11 @@ class TestComputeController(base.TestController):
                 volumes = fakes.volumes.get(tenant["id"], [])
                 if volumes:
                     volumes = volumes[0]["attachments"]
-                floating_ips = fakes.floating_ips[tenant["id"]]
 
                 m_server.return_value = server
                 m_flavor.return_value = flavor
                 m_image.return_value = image
                 m_vol.return_value = volumes
-                m_ips.return_value = floating_ips
 
                 ret = self.controller.show(None, server["id"])
                 # FIXME(aloga): Should we test the resource?
@@ -155,8 +152,6 @@ class TestComputeController(base.TestController):
                 m_flavor.assert_called_with(None, flavor["id"])
                 m_image.assert_called_with(None, image["id"])
                 m_vol.assert_called_with(None, server["id"])
-                if server.get("addresses"):
-                    m_ips.assert_called_with(None)
 
     @mock.patch.object(helpers.OpenStackHelper, "create_server")
     @mock.patch("ooi.occi.validator.Validator")

ooi/tests/controllers/test_network.py

@@ -42,22 +42,9 @@ class TestController(base.TestController):
 
         return webob.Request.blank(path, environ=environ, **kwargs)
 
-    @mock.patch.object(network_api.Controller, "_floating_index")
-    def test_index(self, m_float):
-        res = network.NetworkResource(title="foo",
-                                      id="foo",
-                                      state="active",
-                                      mixins=[network.ip_network])
-
-        m_float.return_value = [res]
-        ret = self.controller.index(None)
-        self.assertIsInstance(ret, collection.Collection)
-        self.assertEqual(res, ret.resources[0])
-        m_float.assert_called_with(None)
-
     @mock.patch("ooi.api.network._build_network")
     @mock.patch.object(network_api.Controller, "_floating_index")
-    def test_general_index(self, m_float, m_build):
+    def test_index(self, m_float, m_build):
         res = network.NetworkResource(title="foo",
                                       id="foo",
                                       state="active",
@@ -69,19 +56,12 @@ class TestController(base.TestController):
 
         m_float.return_value = [res]
         m_build.return_value = res_fixed
-        ret = self.controller.general_index(None)
+        ret = self.controller.index(None)
         self.assertIsInstance(ret, collection.Collection)
         self.assertEqual([res, res_fixed], ret.resources)
         m_float.assert_called_with(None)
         m_build.assert_called_with("fixed")
 
-    def test_fixed(self):
-        ret = self.controller.show_fixed(None)
-        self.assertIsInstance(ret, network.NetworkResource)
-        self.assertEqual("fixed", ret.title)
-        self.assertEqual("fixed", ret.id)
-        self.assertEqual([network.ip_network], ret.mixins)
-
     def test_build(self):
         ret = network_api._build_network("foo")
         self.assertIsInstance(ret, network.NetworkResource)
@@ -100,16 +80,15 @@ class TestController(base.TestController):
     def test_show(self, m_pools):
         for tenant in fakes.tenants.values():
             pools = fakes.pools[tenant["id"]]
+            if not pools:
+                continue
             m_pools.return_value = pools
-            for idx, pool in enumerate(pools):
+            ret = self.controller.show(None, "floating")[0]
-                pool = pools[0]
+            self.assertIsInstance(ret, network.NetworkResource)
-                ret = self.controller.show(None, pool["name"])[0]
+            self.assertEqual("floating", ret.title)
-                self.assertIsInstance(ret, network.NetworkResource)
+            self.assertEqual("floating", ret.id)
-                self.assertEqual(pool["name"], ret.title)
+            self.assertEqual([network.ip_network], ret.mixins)
-                self.assertEqual("%s/%s" % (network_api.FLOATING_PREFIX,
+            m_pools.assert_called_with(None)
-                                            pool["name"]), ret.id)
-                self.assertEqual([network.ip_network], ret.mixins)
-                m_pools.assert_called_with(None)
 
     @mock.patch.object(helpers.OpenStackHelper, "get_floating_ip_pools")
     def test_show_not_found(self, m_pools):
@@ -121,12 +100,19 @@ class TestController(base.TestController):
                           None, uuid.uuid4().hex)
 
     @mock.patch.object(helpers.OpenStackHelper, "get_floating_ip_pools")
-    def test_show_empty(self, m_pools):
+    def test_show_empty_floating(self, m_pools):
+        m_pools.return_value = []
+        self.assertRaises(exception.NetworkNotFound,
+                          self.controller.show,
+                          None, "floating")
+        m_pools.assert_called_with(None)
+
+    @mock.patch.object(helpers.OpenStackHelper, "get_floating_ip_pools")
+    def test_show_non_existent(self, m_pools):
         m_pools.return_value = []
         self.assertRaises(exception.NetworkNotFound,
                           self.controller.show,
                           None, None)
-        m_pools.assert_called_with(None)
 
     @mock.patch.object(helpers.OpenStackHelper, "get_floating_ip_pools")
     def test_floating_ips(self, m_pools):
@@ -134,11 +120,11 @@ class TestController(base.TestController):
             pools = fakes.pools[tenant["id"]]
             m_pools.return_value = pools
             ret = self.controller._floating_index(None)
-            self.assertEqual(len(pools), len(ret))
+            if pools:
-            for idx, el in enumerate(ret):
+                self.assertEqual(1, len(ret))
-                self.assertIsInstance(el, network.NetworkResource)
+                self.assertIsInstance(ret[0], network.NetworkResource)
-                self.assertEqual(pools[idx]["name"], el.title)
+                self.assertEqual("floating", ret[0].title)
-                self.assertEqual("%s/%s" % (network_api.FLOATING_PREFIX,
+                self.assertEqual("floating", ret[0].id)
-                                            pools[idx]["name"]), el.id)
+            else:
-
+                self.assertEqual(0, len(ret))
             m_pools.assert_called_with(None)

ooi/tests/middleware/test_compute_controller.py

@@ -329,8 +329,7 @@ class TestComputeController(test_middleware.TestMiddleware):
                     if addr["OS-EXT-IPS:type"] == "fixed":
                         net_id = "fixed"
                     else:
-                        name = fakes.pools[tenant["id"]][0]["name"]
+                        net_id = "floating"
-                        net_id = "floating/%s" % name
                     target = utils.join_url(self.application_url + "/",
                                             "network/%s" % net_id)
                     self.assertResultIncludesLink(link_id, source, target,

ooi/tests/middleware/test_network_controller.py

@@ -23,7 +23,7 @@ from ooi.tests.middleware import test_middleware
 from ooi import utils
 
 
-def build_occi_network(pool, floating=True):
+def build_occi_network(pool_name):
     cats = []
     cats.append('network; '
                 'scheme="http://schemas.ogf.org/occi/infrastructure#"; '
@@ -32,25 +32,20 @@ def build_occi_network(pool, floating=True):
     cats.append('ipnetwork; '
                 'scheme="http://schemas.ogf.org/occi/infrastructure/'
                 'network#"; class="mixin"; title="IP Networking Mixin"')
-
-    if floating:
-        pool_id = "floating/%s" % pool["name"]
-    else:
-        pool_id = pool["name"]
     attrs = [
-        'occi.core.title="%s"' % pool["name"],
+        'occi.core.title="%s"' % pool_name,
         'occi.network.state="active"',
-        'occi.core.id="%s"' % pool_id,
+        'occi.core.id="%s"' % pool_name,
     ]
     links = []
     links.append('<%s/network/%s?action=up>; '
                  'rel="http://schemas.ogf.org/occi/'
                  'infrastructure/network/action#up"' %
-                 (fakes.application_url, pool_id))
+                 (fakes.application_url, pool_name))
     links.append('<%s/network/%s?action=down>; '
                  'rel="http://schemas.ogf.org/occi/'
                  'infrastructure/network/action#down"' %
-                 (fakes.application_url, pool_id))
+                 (fakes.application_url, pool_name))
     result = []
     for c in cats:
         result.append(("Category", c))
@@ -99,11 +94,11 @@ class TestNetworkController(test_middleware.TestMiddleware):
                 ("X-OCCI-Location",
                  utils.join_url(self.application_url + "/", "network/fixed"))
             ]
-            for s in fakes.pools[tenant["id"]]:
+            if fakes.pools[tenant["id"]]:
                 expected.append(
                     ("X-OCCI-Location",
                      utils.join_url(self.application_url + "/",
-                                    "network/floating/%s" % s["name"]))
+                                    "network/floating"))
                 )
             self.assertDefaults(resp)
             self.assertExpectedResult(expected, resp)
@@ -113,11 +108,10 @@ class TestNetworkController(test_middleware.TestMiddleware):
         app = self.get_app()
 
         for pool in fakes.pools[tenant["id"]]:
-            req = self._build_req("/network/floating/%s" % pool["name"],
+            req = self._build_req("/network/floating", tenant["id"],
-                                  tenant["id"], method="GET")
+                                  method="GET")
-
             resp = req.get_response(app)
-            expected = build_occi_network(pool)
+            expected = build_occi_network("floating")
             self.assertDefaults(resp)
             self.assertExpectedResult(expected, resp)
             self.assertEqual(200, resp.status_code)
@@ -129,7 +123,7 @@ class TestNetworkController(test_middleware.TestMiddleware):
         req = self._build_req("/network/fixed", tenant["id"], method="GET")
 
         resp = req.get_response(app)
-        expected = build_occi_network({"name": "fixed"}, False)
+        expected = build_occi_network("fixed")
         self.assertDefaults(resp)
         self.assertExpectedResult(expected, resp)
         self.assertEqual(200, resp.status_code)
@@ -138,7 +132,7 @@ class TestNetworkController(test_middleware.TestMiddleware):
         tenant = fakes.tenants["foo"]
 
         app = self.get_app()
-        req = self._build_req("/network/floating/%s" % uuid.uuid4().hex,
+        req = self._build_req("/network/%s" % uuid.uuid4().hex,
                               tenant["id"], method="GET")
         resp = req.get_response(app)
         self.assertEqual(404, resp.status_code)

ooi/wsgi/__init__.py

@@ -185,30 +185,10 @@ class OCCIMiddleware(object):
         self._setup_resource_routes("networklink",
                                     self.resources["networklink"])
 
-        # TODO(enolfc): move to _setup_resource_routes or similar
-        # Network is a bit different from other resources
-        # we have /network and below that /network/fixed
-        # and /network/floating/* for the pools
         self.resources["network"] = self._create_resource(
             ooi.api.network.Controller)
-        self.mapper.connect("network", "/network",
+        self._setup_resource_routes("network",
-                            controller=self.resources["network"],
+                                    self.resources["network"])
-                            action="general_index",
-                            conditions=dict(method=["GET"]))
-        # OCCI states that paths must end with a "/" when operating on pahts,
-        # that are not location pahts or resource instances, so we should add
-        # this rule manually
-        self.mapper.connect("network", "/network/",
-                            controller=self.resources["network"],
-                            action="general_index",
-                            conditions=dict(method=["GET"]))
-        self.mapper.connect("fixed_network", "/network/fixed",
-                            controller=self.resources["network"],
-                            action="show_fixed",
-                            conditions=dict(method=["GET"]))
-        netpool_name = "network/%s" % ooi.api.network.FLOATING_PREFIX
-        self.mapper.resource("floating_network", netpool_name,
-                             controller=self.resources["network"])
 
     @webob.dec.wsgify(RequestClass=Request)
     def __call__(self, req):