merging trunk, resolving conflicts

5 files changed, 264 insertions, 40 deletions

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index a2395fead..48066d484 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -118,9 +118,6 @@ class APIRouter(wsgi.Router):
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
 
-        mapper.resource("flavor", "flavors", controller=flavors.Controller(),
-                        collection={'detail': 'GET'})
-
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
@@ -139,6 +136,10 @@ class APIRouterV10(APIRouter):
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.ControllerV10(),
+                        collection={'detail': 'GET'})
+
 
 class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
@@ -153,3 +154,7 @@ class APIRouterV11(APIRouter):
                         controller=server_metadata.Controller(),
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
+
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.ControllerV11(),
+                        collection={'detail': 'GET'})
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index c99b945fb..5b99b5a6f 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -15,16 +15,12 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from webob import exc
+import webob
 
 from nova import db
-from nova import context
-from nova.api.openstack import faults
-from nova.api.openstack import common
-from nova.compute import instance_types
-from nova.api.openstack.views import flavors as flavors_views
+from nova import exception
 from nova import wsgi
-import nova.api.openstack
+from nova.api.openstack import views
 
 
 class Controller(wsgi.Controller):
@@ -33,33 +29,50 @@ class Controller(wsgi.Controller):
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
-                "flavor": ["id", "name", "ram", "disk"]}}}
+                "flavor": ["id", "name", "ram", "disk"],
+                "link": ["rel", "type", "href"],
+            }
+        }
+    }
 
     def index(self, req):
         """Return all flavors in brief."""
-        return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
-                             for flavor in self.detail(req)['flavors']])
+        items = self._get_flavors(req, is_detail=False)
+        return dict(flavors=items)
 
     def detail(self, req):
         """Return all flavors in detail."""
-        items = [self.show(req, id)['flavor'] for id in self._all_ids(req)]
+        items = self._get_flavors(req, is_detail=True)
         return dict(flavors=items)
 
+    def _get_flavors(self, req, is_detail=True):
+        """Helper function that returns a list of flavor dicts."""
+        ctxt = req.environ['nova.context']
+        flavors = db.api.instance_type_get_all(ctxt)
+        builder = self._get_view_builder(req)
+        items = [builder.build(flavor, is_detail=is_detail)
+                 for flavor in flavors.values()]
+        return items
+
     def show(self, req, id):
         """Return data about the given flavor id."""
-        ctxt = req.environ['nova.context']
-        flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
-        values = {
-            "id": flavor["flavorid"],
-            "name": flavor["name"],
-            "ram": flavor["memory_mb"],
-            "disk": flavor["local_gb"],
-        }
+        try:
+            ctxt = req.environ['nova.context']
+            flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
+        except exception.NotFound:
+            return webob.exc.HTTPNotFound()
+
+        builder = self._get_view_builder(req)
+        values = builder.build(flavor, is_detail=True)
         return dict(flavor=values)
 
-    def _all_ids(self, req):
-        """Return the list of all flavorids."""
-        ctxt = req.environ['nova.context']
-        inst_types = db.api.instance_type_get_all(ctxt)
-        flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
-        return sorted(flavor_ids)
+
+class ControllerV10(Controller):
+    def _get_view_builder(self, req):
+        return views.flavors.ViewBuilder()
+
+
+class ControllerV11(Controller):
+    def _get_view_builder(self, req):
+        base_url = req.application_url
+        return views.flavors.ViewBuilderV11(base_url)
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index 18bd779c0..462890ab2 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -19,16 +19,78 @@ from nova.api.openstack import common
 
 
 class ViewBuilder(object):
-    def __init__(self):
-        pass
 
-    def build(self, flavor_obj):
-        raise NotImplementedError()
+    def build(self, flavor_obj, is_detail=False):
+        """Generic method used to generate a flavor entity."""
+        if is_detail:
+            flavor = self._build_detail(flavor_obj)
+        else:
+            flavor = self._build_simple(flavor_obj)
+
+        self._build_extra(flavor)
+
+        return flavor
+
+    def _build_simple(self, flavor_obj):
+        """Build a minimal representation of a flavor."""
+        return {
+            "id": flavor_obj["flavorid"],
+            "name": flavor_obj["name"],
+        }
+
+    def _build_detail(self, flavor_obj):
+        """Build a more complete representation of a flavor."""
+        simple = self._build_simple(flavor_obj)
+
+        detail = {
+            "ram": flavor_obj["memory_mb"],
+            "disk": flavor_obj["local_gb"],
+        }
+
+        detail.update(simple)
+
+        return detail
+
+    def _build_extra(self, flavor_obj):
+        """Hook for version-specific changes to newly created flavor object."""
+        pass
 
 
 class ViewBuilderV11(ViewBuilder):
+    """Openstack API v1.1 flavors view builder."""
+
     def __init__(self, base_url):
+        """
+        :param base_url: url of the root wsgi application
+        """
         self.base_url = base_url
 
+    def _build_extra(self, flavor_obj):
+        flavor_obj["links"] = self._build_links(flavor_obj)
+
+    def _build_links(self, flavor_obj):
+        """Generate a container of links that refer to the provided flavor."""
+        href = self.generate_href(flavor_obj["id"])
+
+        links = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": href,
+            },
+        ]
+
+        return links
+
     def generate_href(self, flavor_id):
+        """Create an url that refers to a specific flavor id."""
         return "%s/flavors/%s" % (self.base_url, flavor_id)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 86eea105d..b2a13a01b 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2389,7 +2389,7 @@ def instance_type_get_by_flavor_id(context, id):
                                     filter_by(flavorid=int(id)).\
                                     first()
     if not inst_type:
-        raise exception.NotFound(_("No flavor with name %s") % id)
+        raise exception.NotFound(_("No flavor with flavorid %s") % id)
     else:
         return dict(inst_type)
 
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 4f504808c..954d72adf 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -19,11 +19,10 @@ import json
 import stubout
 import webob
 
-from nova import test
-import nova.api
+import nova.db.api
 from nova import context
-from nova.api.openstack import flavors
-from nova import db
+from nova import exception
+from nova import test
 from nova.tests.api.openstack import fakes
 
 
@@ -48,6 +47,10 @@ def return_instance_types(context, num=2):
     return instance_types
 
 
+def return_instance_type_not_found(context, flavorid):
+    raise exception.NotFound()
+
+
 class FlavorsTest(test.TestCase):
     def setUp(self):
         super(FlavorsTest, self).setUp()
@@ -67,7 +70,7 @@ class FlavorsTest(test.TestCase):
         self.stubs.UnsetAll()
         super(FlavorsTest, self).tearDown()
 
-    def test_get_flavor_list(self):
+    def test_get_flavor_list_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -84,7 +87,7 @@ class FlavorsTest(test.TestCase):
         ]
         self.assertEqual(flavors, expected)
 
-    def test_get_flavor_list_detail(self):
+    def test_get_flavor_list_detail_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors/detail')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -105,7 +108,7 @@ class FlavorsTest(test.TestCase):
         ]
         self.assertEqual(flavors, expected)
 
-    def test_get_flavor_by_id(self):
+    def test_get_flavor_by_id_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors/12')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -117,3 +120,144 @@ class FlavorsTest(test.TestCase):
             "disk": "10",
         }
         self.assertEqual(flavor, expected)
+
+    def test_get_flavor_by_invalid_id(self):
+        self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
+                       return_instance_type_not_found)
+        req = webob.Request.blank('/v1.0/flavors/asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_flavor_by_id_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/12')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavor"]
+        expected = {
+            "id": "12",
+            "name": "flavor 12",
+            "ram": "256",
+            "disk": "10",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/json",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/xml",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_detail_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/detail')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)