From 67ea462eadcc02ca2f8244062c786bd98871e9e8 Mon Sep 17 00:00:00 2001
From: Eric Day <eday@oddments.org>
Date: Tue, 17 Aug 2010 23:46:16 -0700
Subject: Added unittests for wsgi and api.

---
 nova/api/__init__.py |  5 ++--
 nova/api/test.py     | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 3 deletions(-)
 create mode 100644 nova/api/test.py

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index a6bb93348..b9b9e3988 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -32,7 +32,6 @@ class API(wsgi.Router):
 
     def __init__(self):
         mapper = routes.Mapper()
-        mapper.connect(None, "/v1.0/{path_info:.*}",
-                       controller=rackspace.API())
-        mapper.connect(None, "/ec2/{path_info:.*}", controller=ec2.API())
+        mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API())
+        mapper.connect("/ec2/{path_info:.*}", controller=ec2.API())
         super(API, self).__init__(mapper)
diff --git a/nova/api/test.py b/nova/api/test.py
new file mode 100644
index 000000000..09f79c02e
--- /dev/null
+++ b/nova/api/test.py
@@ -0,0 +1,70 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Test for the root WSGI middleware for all API controllers.
+"""
+
+import unittest
+
+import stubout
+
+from nova import api
+from nova import wsgi_test
+
+
+class Test(unittest.TestCase):
+
+    def setUp(self): # pylint: disable-msg=C0103
+        self.called = False
+        self.stubs = stubout.StubOutForTesting()
+
+    def tearDown(self): # pylint: disable-msg=C0103
+        self.stubs.UnsetAll()
+
+    def test_rackspace(self):
+        self.stubs.Set(api.rackspace, 'API', get_api_stub(self))
+        api.API()(wsgi_test.get_environ({'PATH_INFO': '/v1.0/cloud'}),
+                  wsgi_test.start_response)
+        self.assertTrue(self.called)
+
+    def test_ec2(self):
+        self.stubs.Set(api.ec2, 'API', get_api_stub(self))
+        api.API()(wsgi_test.get_environ({'PATH_INFO': '/ec2/cloud'}),
+                  wsgi_test.start_response)
+        self.assertTrue(self.called)
+
+    def test_not_found(self):
+        self.stubs.Set(api.ec2, 'API', get_api_stub(self))
+        self.stubs.Set(api.rackspace, 'API', get_api_stub(self))
+        api.API()(wsgi_test.get_environ({'PATH_INFO': '/'}),
+                  wsgi_test.start_response)
+        self.assertFalse(self.called)
+
+
+def get_api_stub(test_object):
+    """Get a stub class that verifies next part of the request."""
+
+    class APIStub(object):
+        """Class to verify request and mark it was called."""
+        test = test_object
+
+        def __call__(self, environ, start_response):
+            self.test.assertEqual(environ['PATH_INFO'], '/cloud')
+            self.test.called = True
+
+    return APIStub
-- 
cgit 


From 02592d584cc21e536574d20b01d8dbf82474bcd3 Mon Sep 17 00:00:00 2001
From: Eric Day <eday@oddments.org>
Date: Wed, 18 Aug 2010 15:00:20 -0700
Subject: Updated the tests to use webob, removed the 'called' thing and just
 use return values instead.

---
 nova/api/test.py | 43 +++++++++++++++++--------------------------
 1 file changed, 17 insertions(+), 26 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/test.py b/nova/api/test.py
index 09f79c02e..51b114b8e 100644
--- a/nova/api/test.py
+++ b/nova/api/test.py
@@ -22,49 +22,40 @@ Test for the root WSGI middleware for all API controllers.
 import unittest
 
 import stubout
+import webob
+import webob.dec
 
 from nova import api
-from nova import wsgi_test
 
 
 class Test(unittest.TestCase):
 
     def setUp(self): # pylint: disable-msg=C0103
-        self.called = False
         self.stubs = stubout.StubOutForTesting()
 
     def tearDown(self): # pylint: disable-msg=C0103
         self.stubs.UnsetAll()
 
     def test_rackspace(self):
-        self.stubs.Set(api.rackspace, 'API', get_api_stub(self))
-        api.API()(wsgi_test.get_environ({'PATH_INFO': '/v1.0/cloud'}),
-                  wsgi_test.start_response)
-        self.assertTrue(self.called)
+        self.stubs.Set(api.rackspace, 'API', APIStub)
+        result = webob.Request.blank('/v1.0/cloud').get_response(api.API())
+        self.assertEqual(result.body, "/cloud")
 
     def test_ec2(self):
-        self.stubs.Set(api.ec2, 'API', get_api_stub(self))
-        api.API()(wsgi_test.get_environ({'PATH_INFO': '/ec2/cloud'}),
-                  wsgi_test.start_response)
-        self.assertTrue(self.called)
+        self.stubs.Set(api.ec2, 'API', APIStub)
+        result = webob.Request.blank('/ec2/cloud').get_response(api.API())
+        self.assertEqual(result.body, "/cloud")
 
     def test_not_found(self):
-        self.stubs.Set(api.ec2, 'API', get_api_stub(self))
-        self.stubs.Set(api.rackspace, 'API', get_api_stub(self))
-        api.API()(wsgi_test.get_environ({'PATH_INFO': '/'}),
-                  wsgi_test.start_response)
-        self.assertFalse(self.called)
+        self.stubs.Set(api.ec2, 'API', APIStub)
+        self.stubs.Set(api.rackspace, 'API', APIStub)
+        result = webob.Request.blank('/test/cloud').get_response(api.API())
+        self.assertNotEqual(result.body, "/cloud")
 
 
-def get_api_stub(test_object):
-    """Get a stub class that verifies next part of the request."""
+class APIStub(object):
+    """Class to verify request and mark it was called."""
 
-    class APIStub(object):
-        """Class to verify request and mark it was called."""
-        test = test_object
-
-        def __call__(self, environ, start_response):
-            self.test.assertEqual(environ['PATH_INFO'], '/cloud')
-            self.test.called = True
-
-    return APIStub
+    @webob.dec.wsgify
+    def __call__(self, req):
+        return req.path_info
-- 
cgit 


From b651008e7e4f60f2ccb07497c27d866814156209 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 19 Aug 2010 16:05:27 -0400
Subject: Complete the Image API against a LocalImageService until Glance's API
 exists (at which point we'll make a GlanceImageService and make the choice of
 ImageService plugin configurable.)

---
 nova/api/rackspace/images.py  | 83 +++++++++++++++++++++++++++++--------------
 nova/api/rackspace/notes.txt  | 23 ++++++++++++
 nova/api/services/__init__.py |  0
 nova/api/services/image.py    | 72 +++++++++++++++++++++++++++++++++++++
 4 files changed, 151 insertions(+), 27 deletions(-)
 create mode 100644 nova/api/rackspace/notes.txt
 create mode 100644 nova/api/services/__init__.py
 create mode 100644 nova/api/services/image.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 57c03894a..e29f737a5 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -15,12 +15,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from nova.endpoint.rackspace.controllers.base import BaseController
-from nova.endpoint import images
+from nova import datastore
+from nova.api.rackspace import base
+from nova.api.services.image import ImageService
 from webob import exc
 
 #TODO(gundlach): Serialize return values
-class Controller(BaseController):
+class Controller(base.Controller):
 
     _serialization_metadata = {
         'application/xml': {
@@ -31,34 +32,62 @@ class Controller(BaseController):
         }
     }
 
+    def __init__(self):
+        self._svc = ImageService.load()
+        self._id_xlator = RackspaceApiImageIdTranslator()
+
+    def _to_rs_id(self, image_id):
+        """
+        Convert an image id from the format of our ImageService strategy
+        to the Rackspace API format (an int).
+        """
+        strategy = self._svc.__class__.__name__
+        return self._id_xlator.to_rs_id(strategy, image_id)
+
     def index(self, req):
-        context = req.environ['nova.api_request_context']
-        return images.list(context)
+        """Return all public images."""
+        data = self._svc.list()
+        for img in data:
+            img['id'] = self._to_rs_id(img['id'])
+        return dict(images=result)
 
     def show(self, req, id):
-        context = req.environ['nova.api_request_context']
-        return images.list(context, filter_list=[id])
+        """Return data about the given image id."""
+        img = self._svc.show(id)
+        img['id'] = self._to_rs_id(img['id'])
+        return dict(image=img)
 
     def delete(self, req, id):
-        context = req.environ['nova.api_request_context']
-        # TODO(gundlach): make sure it's an image they may delete?
-        return images.deregister(context, id)
+        # Only public images are supported for now.
+        raise exc.HTTPNotFound()
+
+    def create(self, req):
+        # Only public images are supported for now, so a request to
+        # make a backup of a server cannot be supproted.
+        raise exc.HTTPNotFound()
+
+    def update(self, req, id):
+        # Users may not modify public images, and that's all that 
+        # we support for now.
+        raise exc.HTTPNotFound()
+
+
+class RackspaceApiImageIdTranslator(object):
+    """
+    Converts Rackspace API image ids to and from the id format for a given
+    strategy.
+    """
 
-    def create(self, **kwargs):
-        # TODO(gundlach): no idea how to hook this up.  code below
-        # is from servers.py.
-        inst = self.build_server_instance(kwargs['server'])
-        rpc.cast(
-            FLAGS.compute_topic, {
-                "method": "run_instance",
-                "args": {"instance_id": inst.instance_id}})
+    def __init__(self):
+        self._store = datastore.Redis.instance()
 
-    def update(self, **kwargs):
-        # TODO (gundlach): no idea how to hook this up.  code below
-        # is from servers.py.
-        instance_id = kwargs['id']
-        instance = compute.InstanceDirectory().get(instance_id)
-        if not instance:
-            raise ServerNotFound("The requested server was not found")
-        instance.update(kwargs['server'])
-        instance.save()
+    def to_rs_id(self, strategy_name, opaque_id):
+        """Convert an id from a strategy-specific one to a Rackspace one."""
+        key = "rsapi.idstrategies.image.%s" % strategy_name
+        result = self._store.hget(key, str(opaque_id))
+        if result: # we have a mapping from opaque to RS for this strategy
+            return int(result)
+        else:
+            nextid = self._store.incr("%s.lastid" % key)
+            self._store.hsetnx(key, str(opaque_id), nextid)
+            return nextid
diff --git a/nova/api/rackspace/notes.txt b/nova/api/rackspace/notes.txt
new file mode 100644
index 000000000..e133bf5ea
--- /dev/null
+++ b/nova/api/rackspace/notes.txt
@@ -0,0 +1,23 @@
+We will need:
+
+ImageService
+a service that can do crud on image information.  not user-specific. opaque
+image ids.
+
+GlanceImageService(ImageService):
+image ids are URIs.
+
+LocalImageService(ImageService):
+image ids are random strings.
+
+RackspaceAPITranslationStore:
+translates RS server/images/flavor/etc ids into formats required
+by a given ImageService strategy.
+
+api.rackspace.images.Controller:
+uses an ImageService strategy behind the scenes to do its fetching; it just
+converts int image id into a strategy-specific image id.
+
+who maintains the mapping from user to [images he owns]?  nobody, because
+we have no way of enforcing access to his images, without kryptex which
+won't be in Austin.
diff --git a/nova/api/services/__init__.py b/nova/api/services/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/nova/api/services/image.py b/nova/api/services/image.py
new file mode 100644
index 000000000..c5ea15ba1
--- /dev/null
+++ b/nova/api/services/image.py
@@ -0,0 +1,72 @@
+import cPickle as pickle
+import os.path
+import string
+
+class ImageService(object):
+    """Provides storage and retrieval of disk image objects."""
+
+    @staticmethod
+    def load():
+        """Factory method to return image service."""
+        #TODO(gundlach): read from config.
+        class_ = LocalImageService
+        return class_()
+
+    def index(self):
+        """
+        Return a list of image data dicts.  Each dict will contain an
+        id key whose value is an opaque image id.
+        """
+
+    def show(self, id):
+        """
+        Returns a dict containing image data for the given opaque image id.
+        """
+
+
+class GlanceImageService(ImageService):
+    """Provides storage and retrieval of disk image objects within Glance."""
+    # TODO(gundlach): once Glance has an API, build this.
+    pass
+
+
+class LocalImageService(ImageService):
+    """Image service storing images to local disk."""
+
+    def __init__(self):
+        self._path = "/tmp/nova/images"
+        try:
+            os.makedirs(self._path)
+        except OSError: # exists
+            pass
+
+    def _path_to(self, image_id=''):
+        return os.path.join(self._path, image_id)
+
+    def _ids(self):
+        """The list of all image ids."""
+        return os.path.listdir(self._path)
+
+    def index(self):
+        return [ self.show(id) for id in self._ids() ]
+
+    def show(self, id):
+        return pickle.load(open(self._path_to(id))) 
+
+    def create(self, data):
+        """
+        Store the image data and return the new image id.
+        """
+        id = ''.join(random.choice(string.letters) for _ in range(20))
+        self.update(id, data)
+        return id
+
+    def update(self, image_id, data):
+        """Replace the contents of the given image with the new data."""
+        pickle.dump(data, open(self._path_to(image_id), 'w'))
+
+    def delete(self, image_id):
+        """
+        Delete the given image.  Raises OSError if the image does not exist.
+        """
+        os.unlink(self._path_to(image_id))
-- 
cgit 


From d38f21e0fb382bd8f01cfbc79cb34ea8710cd639 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 10:27:59 -0400
Subject: License

---
 nova/api/services/image.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/services/image.py b/nova/api/services/image.py
index c5ea15ba1..bda50fc66 100644
--- a/nova/api/services/image.py
+++ b/nova/api/services/image.py
@@ -1,3 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
 import cPickle as pickle
 import os.path
 import string
-- 
cgit 


From e3727d6d88a0631d3b896c4fcdcfec05510dad36 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 12:07:20 -0400
Subject: Support opaque id to rs int id as well

---
 nova/api/rackspace/images.py | 42 ++++++++++++++++++++++++++++++++----------
 nova/api/services/image.py   |  8 ++++----
 2 files changed, 36 insertions(+), 14 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index e29f737a5..c9cc8e85d 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -44,18 +44,24 @@ class Controller(base.Controller):
         strategy = self._svc.__class__.__name__
         return self._id_xlator.to_rs_id(strategy, image_id)
 
+    def _from_rs_id(self, rs_image_id):
+        """
+        Convert an image id from the Rackspace API format (an int) to the
+        format of our ImageService strategy.
+        """
+        strategy = self._svc.__class__.__name__
+        return self._id_xlator.from_rs_id(strategy, rs_image_id)
+
     def index(self, req):
         """Return all public images."""
-        data = self._svc.list()
-        for img in data:
-            img['id'] = self._to_rs_id(img['id'])
-        return dict(images=result)
+        data = dict((self._to_rs_id(id), val) 
+                    for id, val in self._svc.index().iteritems())
+        return dict(images=data)
 
     def show(self, req, id):
         """Return data about the given image id."""
-        img = self._svc.show(id)
-        img['id'] = self._to_rs_id(img['id'])
-        return dict(image=img)
+        opaque_id = self._from_rs_id(id)
+        return dict(image=self._svc.show(opaque_id))
 
     def delete(self, req, id):
         # Only public images are supported for now.
@@ -80,14 +86,30 @@ class RackspaceApiImageIdTranslator(object):
 
     def __init__(self):
         self._store = datastore.Redis.instance()
+        self._key_template = "rsapi.idstrategies.image.%s.%s"
 
     def to_rs_id(self, strategy_name, opaque_id):
         """Convert an id from a strategy-specific one to a Rackspace one."""
-        key = "rsapi.idstrategies.image.%s" % strategy_name
+        key = self._key_template % (strategy_name, "fwd")
         result = self._store.hget(key, str(opaque_id))
         if result: # we have a mapping from opaque to RS for this strategy
             return int(result)
         else:
+            # Store the mapping.
             nextid = self._store.incr("%s.lastid" % key)
-            self._store.hsetnx(key, str(opaque_id), nextid)
-            return nextid
+            if self._store.hsetnx(key, str(opaque_id), nextid):
+                # If someone else didn't beat us to it, store the reverse
+                # mapping as well.
+                key = self._key_template % (strategy_name, "rev")
+                self._store.hset(key, nextid, str(opaque_id))
+                return nextid
+            else:
+                # Someone beat us to it; use their number instead, and
+                # discard nextid (which is OK -- we don't require that
+                # every int id be used.)
+                return int(self._store.hget(key, str(opaque_id)))
+
+    def from_rs_id(self, strategy_name, rs_id):
+        """Convert a Rackspace id to a strategy-specific one."""
+        key = self._key_template % (strategy_name, "rev")
+        return self._store.hget(key, rs_id)
diff --git a/nova/api/services/image.py b/nova/api/services/image.py
index bda50fc66..11e19804a 100644
--- a/nova/api/services/image.py
+++ b/nova/api/services/image.py
@@ -17,6 +17,7 @@
 
 import cPickle as pickle
 import os.path
+import random
 import string
 
 class ImageService(object):
@@ -31,8 +32,7 @@ class ImageService(object):
 
     def index(self):
         """
-        Return a list of image data dicts.  Each dict will contain an
-        id key whose value is an opaque image id.
+        Return a dict from opaque image id to image data.
         """
 
     def show(self, id):
@@ -62,10 +62,10 @@ class LocalImageService(ImageService):
 
     def _ids(self):
         """The list of all image ids."""
-        return os.path.listdir(self._path)
+        return os.listdir(self._path)
 
     def index(self):
-        return [ self.show(id) for id in self._ids() ]
+        return dict((id, self.show(id)) for id in self._ids())
 
     def show(self, id):
         return pickle.load(open(self._path_to(id))) 
-- 
cgit 


From 030d01fd10f7f65cdafbea49e04f3b6b147a7348 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 12:46:29 -0400
Subject: Serialize properly

---
 nova/api/rackspace/base.py   | 3 ++-
 nova/api/rackspace/images.py | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/base.py b/nova/api/rackspace/base.py
index c85fd7b8e..b995d9acc 100644
--- a/nova/api/rackspace/base.py
+++ b/nova/api/rackspace/base.py
@@ -36,4 +36,5 @@ class Controller(wsgi.Controller):
         MIME types to information needed to serialize to that type.
         """
         _metadata = getattr(type(self), "_serialization_metadata", {})
-        return Serializer(request.environ, _metadata).to_content_type(data)
+        serializer = wsgi.Serializer(request.environ, _metadata)
+        return serializer.to_content_type(data)
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index c9cc8e85d..62e0b24c5 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -56,12 +56,12 @@ class Controller(base.Controller):
         """Return all public images."""
         data = dict((self._to_rs_id(id), val) 
                     for id, val in self._svc.index().iteritems())
-        return dict(images=data)
+        return self.serialize(dict(images=data), req)
 
     def show(self, req, id):
         """Return data about the given image id."""
         opaque_id = self._from_rs_id(id)
-        return dict(image=self._svc.show(opaque_id))
+        return self.serialize(dict(image=self._svc.show(opaque_id)), req)
 
     def delete(self, req, id):
         # Only public images are supported for now.
-- 
cgit 


From a50a200bc2547439a3da17e695224d3d434e14dd Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 12:55:57 -0400
Subject: Move serialize() to wsgi.Controller so __call__ can serialize()
 action return values if they are dicts.

---
 nova/api/rackspace/base.py | 10 ----------
 1 file changed, 10 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/base.py b/nova/api/rackspace/base.py
index b995d9acc..51841925e 100644
--- a/nova/api/rackspace/base.py
+++ b/nova/api/rackspace/base.py
@@ -28,13 +28,3 @@ class Controller(wsgi.Controller):
             return {cls.entity_name: cls.render(instance)}
         else:
             return { "TODO": "TODO" }
-    
-    def serialize(self, data, request):
-        """
-        Serialize the given dict to the response type requested in request.
-        Uses self._serialization_metadata if it exists, which is a dict mapping
-        MIME types to information needed to serialize to that type.
-        """
-        _metadata = getattr(type(self), "_serialization_metadata", {})
-        serializer = wsgi.Serializer(request.environ, _metadata)
-        return serializer.to_content_type(data)
-- 
cgit 


From f5c03fdd78a3bb8233e465c7624ed1fdb8f400fe Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 13:06:40 -0400
Subject: Don't serialize in Controller subclass now that wsgi.Controller
 handles it for us

---
 nova/api/rackspace/images.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 62e0b24c5..070100143 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -20,7 +20,6 @@ from nova.api.rackspace import base
 from nova.api.services.image import ImageService
 from webob import exc
 
-#TODO(gundlach): Serialize return values
 class Controller(base.Controller):
 
     _serialization_metadata = {
@@ -56,12 +55,12 @@ class Controller(base.Controller):
         """Return all public images."""
         data = dict((self._to_rs_id(id), val) 
                     for id, val in self._svc.index().iteritems())
-        return self.serialize(dict(images=data), req)
+        return dict(images=data)
 
     def show(self, req, id):
         """Return data about the given image id."""
         opaque_id = self._from_rs_id(id)
-        return self.serialize(dict(image=self._svc.show(opaque_id)), req)
+        return dict(image=self._svc.show(opaque_id))
 
     def delete(self, req, id):
         # Only public images are supported for now.
-- 
cgit 


From 35a08780c41ece1b47b2ded98c061b103a400fea Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 13:26:10 -0400
Subject: Get the output formatting correct.

---
 nova/api/rackspace/images.py | 9 ++++++---
 nova/api/services/image.py   | 3 ++-
 2 files changed, 8 insertions(+), 4 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 070100143..7d32fa099 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -53,14 +53,17 @@ class Controller(base.Controller):
 
     def index(self, req):
         """Return all public images."""
-        data = dict((self._to_rs_id(id), val) 
-                    for id, val in self._svc.index().iteritems())
+        data = self._svc.index()
+        for img in data:
+            img['id'] = self._to_rs_id(img['id'])
         return dict(images=data)
 
     def show(self, req, id):
         """Return data about the given image id."""
         opaque_id = self._from_rs_id(id)
-        return dict(image=self._svc.show(opaque_id))
+        img = self._svc.show(opaque_id)
+        img['id'] = id
+        return dict(image=img)
 
     def delete(self, req, id):
         # Only public images are supported for now.
diff --git a/nova/api/services/image.py b/nova/api/services/image.py
index 11e19804a..1a7a258b7 100644
--- a/nova/api/services/image.py
+++ b/nova/api/services/image.py
@@ -65,7 +65,7 @@ class LocalImageService(ImageService):
         return os.listdir(self._path)
 
     def index(self):
-        return dict((id, self.show(id)) for id in self._ids())
+        return [ self.show(id) for id in self._ids() ]
 
     def show(self, id):
         return pickle.load(open(self._path_to(id))) 
@@ -75,6 +75,7 @@ class LocalImageService(ImageService):
         Store the image data and return the new image id.
         """
         id = ''.join(random.choice(string.letters) for _ in range(20))
+        data['id'] = id
         self.update(id, data)
         return id
 
-- 
cgit 


From 41e2e91ccfb1409f1ea47d92a9d15f47ab37e65d Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 23 Aug 2010 16:43:25 -0400
Subject: Merge fail

---
 nova/api/rackspace/base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/base.py b/nova/api/rackspace/base.py
index 51841925e..dd2c6543c 100644
--- a/nova/api/rackspace/base.py
+++ b/nova/api/rackspace/base.py
@@ -27,4 +27,4 @@ class Controller(wsgi.Controller):
         if isinstance(instance, list):
             return {cls.entity_name: cls.render(instance)}
         else:
-            return { "TODO": "TODO" }
+            return {"TODO": "TODO"}
-- 
cgit 


From d94eec3d2995c97c38006e4d6177740375860f8f Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 24 Aug 2010 11:19:51 -0400
Subject: Style fixes

---
 nova/api/rackspace/images.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 7d32fa099..36a26688c 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -17,7 +17,7 @@
 
 from nova import datastore
 from nova.api.rackspace import base
-from nova.api.services.image import ImageService
+from nova.api.services import image
 from webob import exc
 
 class Controller(base.Controller):
@@ -32,28 +32,28 @@ class Controller(base.Controller):
     }
 
     def __init__(self):
-        self._svc = ImageService.load()
-        self._id_xlator = RackspaceApiImageIdTranslator()
+        self._service = image.ImageService.load()
+        self._id_translator = RackspaceAPIImageIdTranslator()
 
     def _to_rs_id(self, image_id):
         """
         Convert an image id from the format of our ImageService strategy
         to the Rackspace API format (an int).
         """
-        strategy = self._svc.__class__.__name__
-        return self._id_xlator.to_rs_id(strategy, image_id)
+        strategy = self._service.__class__.__name__
+        return self._id_translator.to_rs_id(strategy, image_id)
 
     def _from_rs_id(self, rs_image_id):
         """
         Convert an image id from the Rackspace API format (an int) to the
         format of our ImageService strategy.
         """
-        strategy = self._svc.__class__.__name__
-        return self._id_xlator.from_rs_id(strategy, rs_image_id)
+        strategy = self._service.__class__.__name__
+        return self._id_translator.from_rs_id(strategy, rs_image_id)
 
     def index(self, req):
         """Return all public images."""
-        data = self._svc.index()
+        data = self._service.index()
         for img in data:
             img['id'] = self._to_rs_id(img['id'])
         return dict(images=data)
@@ -61,7 +61,7 @@ class Controller(base.Controller):
     def show(self, req, id):
         """Return data about the given image id."""
         opaque_id = self._from_rs_id(id)
-        img = self._svc.show(opaque_id)
+        img = self._service.show(opaque_id)
         img['id'] = id
         return dict(image=img)
 
@@ -80,7 +80,7 @@ class Controller(base.Controller):
         raise exc.HTTPNotFound()
 
 
-class RackspaceApiImageIdTranslator(object):
+class RackspaceAPIImageIdTranslator(object):
     """
     Converts Rackspace API image ids to and from the id format for a given
     strategy.
-- 
cgit 


From 09bc71460b976f28c7bc6a507006d6c7c12c5824 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 24 Aug 2010 16:16:41 -0400
Subject: Move imageservice to its own directory

---
 nova/api/rackspace/images.py |  4 +-
 nova/api/services/image.py   | 90 --------------------------------------------
 2 files changed, 2 insertions(+), 92 deletions(-)
 delete mode 100644 nova/api/services/image.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 36a26688c..b7668a1e1 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -17,7 +17,7 @@
 
 from nova import datastore
 from nova.api.rackspace import base
-from nova.api.services import image
+from nova import image
 from webob import exc
 
 class Controller(base.Controller):
@@ -32,7 +32,7 @@ class Controller(base.Controller):
     }
 
     def __init__(self):
-        self._service = image.ImageService.load()
+        self._service = image.service.ImageService.load()
         self._id_translator = RackspaceAPIImageIdTranslator()
 
     def _to_rs_id(self, image_id):
diff --git a/nova/api/services/image.py b/nova/api/services/image.py
deleted file mode 100644
index 1a7a258b7..000000000
--- a/nova/api/services/image.py
+++ /dev/null
@@ -1,90 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import cPickle as pickle
-import os.path
-import random
-import string
-
-class ImageService(object):
-    """Provides storage and retrieval of disk image objects."""
-
-    @staticmethod
-    def load():
-        """Factory method to return image service."""
-        #TODO(gundlach): read from config.
-        class_ = LocalImageService
-        return class_()
-
-    def index(self):
-        """
-        Return a dict from opaque image id to image data.
-        """
-
-    def show(self, id):
-        """
-        Returns a dict containing image data for the given opaque image id.
-        """
-
-
-class GlanceImageService(ImageService):
-    """Provides storage and retrieval of disk image objects within Glance."""
-    # TODO(gundlach): once Glance has an API, build this.
-    pass
-
-
-class LocalImageService(ImageService):
-    """Image service storing images to local disk."""
-
-    def __init__(self):
-        self._path = "/tmp/nova/images"
-        try:
-            os.makedirs(self._path)
-        except OSError: # exists
-            pass
-
-    def _path_to(self, image_id=''):
-        return os.path.join(self._path, image_id)
-
-    def _ids(self):
-        """The list of all image ids."""
-        return os.listdir(self._path)
-
-    def index(self):
-        return [ self.show(id) for id in self._ids() ]
-
-    def show(self, id):
-        return pickle.load(open(self._path_to(id))) 
-
-    def create(self, data):
-        """
-        Store the image data and return the new image id.
-        """
-        id = ''.join(random.choice(string.letters) for _ in range(20))
-        data['id'] = id
-        self.update(id, data)
-        return id
-
-    def update(self, image_id, data):
-        """Replace the contents of the given image with the new data."""
-        pickle.dump(data, open(self._path_to(image_id), 'w'))
-
-    def delete(self, image_id):
-        """
-        Delete the given image.  Raises OSError if the image does not exist.
-        """
-        os.unlink(self._path_to(image_id))
-- 
cgit 


From 5f832cd5ea9fb858f5e8b09992cbd47d8d16f665 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 24 Aug 2010 16:17:06 -0400
Subject: Delete unused directory

---
 nova/api/services/__init__.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 nova/api/services/__init__.py

(limited to 'nova/api')

diff --git a/nova/api/services/__init__.py b/nova/api/services/__init__.py
deleted file mode 100644
index e69de29bb..000000000
-- 
cgit 


From 96ae5e2776218adfee2cb22a4c0d7358a498a451 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 24 Aug 2010 16:24:24 -0400
Subject: pep8

---
 nova/api/rackspace/images.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index b7668a1e1..370980fe9 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -16,8 +16,8 @@
 #    under the License.
 
 from nova import datastore
-from nova.api.rackspace import base
 from nova import image
+from nova.api.rackspace import base
 from webob import exc
 
 class Controller(base.Controller):
-- 
cgit 


From 3b70003d932607ccc13fe4cd9381475035603a70 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 24 Aug 2010 17:03:03 -0400
Subject: Flavors work

---
 nova/api/rackspace/flavors.py | 34 +++++++++++++++++++++++-
 nova/api/rackspace/images.py  | 62 ++++---------------------------------------
 2 files changed, 38 insertions(+), 58 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 986f11434..8c5ffa438 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -15,4 +15,36 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-class Controller(object): pass
+from nova.api.rackspace import base
+from nova.api.rackspace import _id_translator
+from nova import flavor
+from webob import exc
+
+class Controller(base.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "flavor": [ "id", "name", "ram", "disk" ]
+            }
+        }
+    }
+
+    def __init__(self):
+        self._service = flavor.service.FlavorService.load()
+        self._id_translator = self._id_translator.RackspaceAPIIdTranslator(
+                "flavor", self._service.__class__.__name__)
+
+    def index(self, req):
+        """Return all flavors."""
+        items = self._service.index()
+        for flavor in items:
+            flavor['id'] = self._id_translator.to_rs_id(flavor['id'])
+        return dict(flavors=items)
+
+    def show(self, req, id):
+        """Return data about the given flavor id."""
+        opaque_id = self._id_translator.from_rs_id(id)
+        item = self._service.show(opaque_id)
+        item['id'] = id
+        return dict(flavor=item)
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 36a26688c..09f55ea96 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -15,8 +15,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from nova import datastore
 from nova.api.rackspace import base
+from nova.api.rackspace import _id_translator
 from nova.api.services import image
 from webob import exc
 
@@ -33,34 +33,19 @@ class Controller(base.Controller):
 
     def __init__(self):
         self._service = image.ImageService.load()
-        self._id_translator = RackspaceAPIImageIdTranslator()
-
-    def _to_rs_id(self, image_id):
-        """
-        Convert an image id from the format of our ImageService strategy
-        to the Rackspace API format (an int).
-        """
-        strategy = self._service.__class__.__name__
-        return self._id_translator.to_rs_id(strategy, image_id)
-
-    def _from_rs_id(self, rs_image_id):
-        """
-        Convert an image id from the Rackspace API format (an int) to the
-        format of our ImageService strategy.
-        """
-        strategy = self._service.__class__.__name__
-        return self._id_translator.from_rs_id(strategy, rs_image_id)
+        self._id_translator = _id_translator.RackspaceAPIIdTranslator(
+                "image", self._service.__class__.__name__)
 
     def index(self, req):
         """Return all public images."""
         data = self._service.index()
         for img in data:
-            img['id'] = self._to_rs_id(img['id'])
+            img['id'] = self._id_translator.to_rs_id(img['id'])
         return dict(images=data)
 
     def show(self, req, id):
         """Return data about the given image id."""
-        opaque_id = self._from_rs_id(id)
+        opaque_id = self._id_translator.from_rs_id(id)
         img = self._service.show(opaque_id)
         img['id'] = id
         return dict(image=img)
@@ -78,40 +63,3 @@ class Controller(base.Controller):
         # Users may not modify public images, and that's all that 
         # we support for now.
         raise exc.HTTPNotFound()
-
-
-class RackspaceAPIImageIdTranslator(object):
-    """
-    Converts Rackspace API image ids to and from the id format for a given
-    strategy.
-    """
-
-    def __init__(self):
-        self._store = datastore.Redis.instance()
-        self._key_template = "rsapi.idstrategies.image.%s.%s"
-
-    def to_rs_id(self, strategy_name, opaque_id):
-        """Convert an id from a strategy-specific one to a Rackspace one."""
-        key = self._key_template % (strategy_name, "fwd")
-        result = self._store.hget(key, str(opaque_id))
-        if result: # we have a mapping from opaque to RS for this strategy
-            return int(result)
-        else:
-            # Store the mapping.
-            nextid = self._store.incr("%s.lastid" % key)
-            if self._store.hsetnx(key, str(opaque_id), nextid):
-                # If someone else didn't beat us to it, store the reverse
-                # mapping as well.
-                key = self._key_template % (strategy_name, "rev")
-                self._store.hset(key, nextid, str(opaque_id))
-                return nextid
-            else:
-                # Someone beat us to it; use their number instead, and
-                # discard nextid (which is OK -- we don't require that
-                # every int id be used.)
-                return int(self._store.hget(key, str(opaque_id)))
-
-    def from_rs_id(self, strategy_name, rs_id):
-        """Convert a Rackspace id to a strategy-specific one."""
-        key = self._key_template % (strategy_name, "rev")
-        return self._store.hget(key, rs_id)
-- 
cgit 


From 0828326898e3bc219c8205e27a3cc942e2790934 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 25 Aug 2010 16:27:01 -0400
Subject: Use compute.instance_types for flavor data instead of a FlavorService

---
 nova/api/rackspace/flavors.py | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 8c5ffa438..59981f1c5 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -16,11 +16,11 @@
 #    under the License.
 
 from nova.api.rackspace import base
-from nova.api.rackspace import _id_translator
-from nova import flavor
+from nova.compute import instance_types
 from webob import exc
 
 class Controller(base.Controller):
+    """Flavor controller for the Rackspace API."""
 
     _serialization_metadata = {
         'application/xml': {
@@ -30,21 +30,20 @@ class Controller(base.Controller):
         }
     }
 
-    def __init__(self):
-        self._service = flavor.service.FlavorService.load()
-        self._id_translator = self._id_translator.RackspaceAPIIdTranslator(
-                "flavor", self._service.__class__.__name__)
-
     def index(self, req):
         """Return all flavors."""
-        items = self._service.index()
-        for flavor in items:
-            flavor['id'] = self._id_translator.to_rs_id(flavor['id'])
+        items = [self.show(req, id)['flavor'] for id in self._all_ids()]
         return dict(flavors=items)
 
     def show(self, req, id):
         """Return data about the given flavor id."""
-        opaque_id = self._id_translator.from_rs_id(id)
-        item = self._service.show(opaque_id)
-        item['id'] = id
-        return dict(flavor=item)
+        for name, val in instance_types.INSTANCE_TYPES.iteritems():
+            if val['flavorid'] == int(id):
+                item = dict(ram=val['memory_mb'], disk=val['local_gb'],
+                            id=val['flavorid'], name=name)
+                return dict(flavor=item)
+        raise exc.HTTPNotFound()
+
+    def _all_ids(self):
+        """Return the list of all flavorids."""
+        return [i['flavorid'] for i in instance_types.INSTANCE_TYPES.values()]
-- 
cgit 


From cf0b5de1f78fd81ada2bada8c84e26b3238b8596 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 25 Aug 2010 16:46:53 -0400
Subject: Turn imageid translator into general translator for rackspace api ids

---
 nova/api/rackspace/_id_translator.py | 42 ++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 nova/api/rackspace/_id_translator.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/_id_translator.py b/nova/api/rackspace/_id_translator.py
new file mode 100644
index 000000000..aec5fb6a5
--- /dev/null
+++ b/nova/api/rackspace/_id_translator.py
@@ -0,0 +1,42 @@
+from nova import datastore
+
+class RackspaceAPIIdTranslator(object):
+    """
+    Converts Rackspace API ids to and from the id format for a given
+    strategy.
+    """
+
+    def __init__(self, id_type, service_name):
+        """
+        Creates a translator for ids of the given type (e.g. 'flavor'), for the
+        given storage service backend class name (e.g. 'LocalFlavorService').
+        """
+
+        self._store = datastore.Redis.instance()
+        key_prefix = "rsapi.idtranslator.%s.%s" % (id_type, service_name)
+        # Forward (strategy format -> RS format) and reverse translation keys
+        self._fwd_key = "%s.fwd" % key_prefix
+        self._rev_key = "%s.rev" % key_prefix
+
+    def to_rs_id(self, opaque_id):
+        """Convert an id from a strategy-specific one to a Rackspace one."""
+        result = self._store.hget(self._fwd_key, str(opaque_id))
+        if result: # we have a mapping from opaque to RS for this strategy
+            return int(result)
+        else:
+            # Store the mapping.
+            nextid = self._store.incr("%s.lastid" % self._fwd_key)
+            if self._store.hsetnx(self._fwd_key, str(opaque_id), nextid):
+                # If someone else didn't beat us to it, store the reverse
+                # mapping as well.
+                self._store.hset(self._rev_key, nextid, str(opaque_id))
+                return nextid
+            else:
+                # Someone beat us to it; use their number instead, and
+                # discard nextid (which is OK -- we don't require that
+                # every int id be used.)
+                return int(self._store.hget(self._fwd_key, str(opaque_id)))
+
+    def from_rs_id(self, strategy_name, rs_id):
+        """Convert a Rackspace id to a strategy-specific one."""
+        return self._store.hget(self._rev_key, rs_id)
-- 
cgit 


From 8b58c7296ae394772dab82fbb76469722798cc29 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 25 Aug 2010 16:37:22 -0500
Subject: Moved API tests into a sub-folder of the tests/ and added a
 stubbed-out test declarations to mirror existing API tickets

---
 nova/api/test.py | 61 --------------------------------------------------------
 1 file changed, 61 deletions(-)
 delete mode 100644 nova/api/test.py

(limited to 'nova/api')

diff --git a/nova/api/test.py b/nova/api/test.py
deleted file mode 100644
index 51b114b8e..000000000
--- a/nova/api/test.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Test for the root WSGI middleware for all API controllers.
-"""
-
-import unittest
-
-import stubout
-import webob
-import webob.dec
-
-from nova import api
-
-
-class Test(unittest.TestCase):
-
-    def setUp(self): # pylint: disable-msg=C0103
-        self.stubs = stubout.StubOutForTesting()
-
-    def tearDown(self): # pylint: disable-msg=C0103
-        self.stubs.UnsetAll()
-
-    def test_rackspace(self):
-        self.stubs.Set(api.rackspace, 'API', APIStub)
-        result = webob.Request.blank('/v1.0/cloud').get_response(api.API())
-        self.assertEqual(result.body, "/cloud")
-
-    def test_ec2(self):
-        self.stubs.Set(api.ec2, 'API', APIStub)
-        result = webob.Request.blank('/ec2/cloud').get_response(api.API())
-        self.assertEqual(result.body, "/cloud")
-
-    def test_not_found(self):
-        self.stubs.Set(api.ec2, 'API', APIStub)
-        self.stubs.Set(api.rackspace, 'API', APIStub)
-        result = webob.Request.blank('/test/cloud').get_response(api.API())
-        self.assertNotEqual(result.body, "/cloud")
-
-
-class APIStub(object):
-    """Class to verify request and mark it was called."""
-
-    @webob.dec.wsgify
-    def __call__(self, req):
-        return req.path_info
-- 
cgit 


From c9d3b7c3ae71bbbe6f3077dcee13be41a14a6733 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 25 Aug 2010 17:48:08 -0400
Subject: Support GET /<controller>/detail

---
 nova/api/rackspace/__init__.py |  6 ++++--
 nova/api/rackspace/flavors.py  |  7 ++++++-
 nova/api/rackspace/images.py   | 11 ++++++++---
 3 files changed, 18 insertions(+), 6 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index 27e78f801..b4d666d63 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -74,8 +74,10 @@ class APIRouter(wsgi.Router):
     def __init__(self):
         mapper = routes.Mapper()
         mapper.resource("server", "servers", controller=servers.Controller())
-        mapper.resource("image", "images", controller=images.Controller())
-        mapper.resource("flavor", "flavors", controller=flavors.Controller())
+        mapper.resource("image", "images", controller=images.Controller(),
+                        collection={'detail': 'GET'})
+        mapper.resource("flavor", "flavors", controller=flavors.Controller(),
+                        collection={'detail': 'GET'})
         mapper.resource("sharedipgroup", "sharedipgroups",
                         controller=sharedipgroups.Controller())
         super(APIRouter, self).__init__(mapper)
diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 59981f1c5..60b35c939 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -31,7 +31,12 @@ class Controller(base.Controller):
     }
 
     def index(self, req):
-        """Return all flavors."""
+        """Return all flavors in brief."""
+        return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
+                             for flavor in self.detail(req)['flavors']])
+
+    def detail(self, req):
+        """Return all flavors in detail."""
         items = [self.show(req, id)['flavor'] for id in self._all_ids()]
         return dict(flavors=items)
 
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 06fb0d38f..2f3e928b9 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -15,7 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from nova import image
+import nova.image.service
 from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
 from webob import exc
@@ -32,12 +32,17 @@ class Controller(base.Controller):
     }
 
     def __init__(self):
-        self._service = image.ImageService.load()
+        self._service = nova.image.service.ImageService.load()
         self._id_translator = _id_translator.RackspaceAPIIdTranslator(
                 "image", self._service.__class__.__name__)
 
     def index(self, req):
-        """Return all public images."""
+        """Return all public images in brief."""
+        return dict(images=[dict(id=img['id'], name=img['name'])
+                            for img in self.detail(req)['images']])
+
+    def detail(self, req):
+        """Return all public images in detail."""
         data = self._service.index()
         for img in data:
             img['id'] = self._id_translator.to_rs_id(img['id'])
-- 
cgit 


From 909c24b9cd35d6752f9f051f4e9a80ce30eaee4d Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 30 Aug 2010 19:04:51 -0400
Subject: Move class into its own file

---
 nova/api/ec2/apirequesthandler.py | 126 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 nova/api/ec2/apirequesthandler.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/apirequesthandler.py b/nova/api/ec2/apirequesthandler.py
new file mode 100644
index 000000000..bbba60c02
--- /dev/null
+++ b/nova/api/ec2/apirequesthandler.py
@@ -0,0 +1,126 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequestHandler, pulled unmodified out of nova.endpoint.api
+"""
+
+import logging
+
+import tornado.web
+
+from nova import exception
+from nova import utils
+from nova.auth import manager
+
+
+_log = logging.getLogger("api")
+_log.setLevel(logging.DEBUG)
+
+
+class APIRequestHandler(tornado.web.RequestHandler):
+    def get(self, controller_name):
+        self.execute(controller_name)
+
+    @tornado.web.asynchronous
+    def execute(self, controller_name):
+        # Obtain the appropriate controller for this request.
+        try:
+            controller = self.application.controllers[controller_name]
+        except KeyError:
+            self._error('unhandled', 'no controller named %s' % controller_name)
+            return
+
+        args = self.request.arguments
+
+        # Read request signature.
+        try:
+            signature = args.pop('Signature')[0]
+        except:
+            raise tornado.web.HTTPError(400)
+
+        # Make a copy of args for authentication and signature verification.
+        auth_params = {}
+        for key, value in args.items():
+            auth_params[key] = value[0]
+
+        # Get requested action and remove authentication args for final request.
+        try:
+            action = args.pop('Action')[0]
+            access = args.pop('AWSAccessKeyId')[0]
+            args.pop('SignatureMethod')
+            args.pop('SignatureVersion')
+            args.pop('Version')
+            args.pop('Timestamp')
+        except:
+            raise tornado.web.HTTPError(400)
+
+        # Authenticate the request.
+        try:
+            (user, project) = manager.AuthManager().authenticate(
+                access,
+                signature,
+                auth_params,
+                self.request.method,
+                self.request.host,
+                self.request.path
+            )
+
+        except exception.Error, ex:
+            logging.debug("Authentication Failure: %s" % ex)
+            raise tornado.web.HTTPError(403)
+
+        _log.debug('action: %s' % action)
+
+        for key, value in args.items():
+            _log.debug('arg: %s\t\tval: %s' % (key, value))
+
+        request = APIRequest(controller, action)
+        context = APIRequestContext(self, user, project)
+        d = request.send(context, **args)
+        # d.addCallback(utils.debug)
+
+        # TODO: Wrap response in AWS XML format
+        d.addCallbacks(self._write_callback, self._error_callback)
+
+    def _write_callback(self, data):
+        self.set_header('Content-Type', 'text/xml')
+        self.write(data)
+        self.finish()
+
+    def _error_callback(self, failure):
+        try:
+            failure.raiseException()
+        except exception.ApiError as ex:
+            self._error(type(ex).__name__ + "." + ex.code, ex.message)
+        # TODO(vish): do something more useful with unknown exceptions
+        except Exception as ex:
+            self._error(type(ex).__name__, str(ex))
+            raise
+
+    def post(self, controller_name):
+        self.execute(controller_name)
+
+    def _error(self, code, message):
+        self._status_code = 400
+        self.set_header('Content-Type', 'text/xml')
+        self.write('<?xml version="1.0"?>\n')
+        self.write('<Response><Errors><Error><Code>%s</Code>'
+                   '<Message>%s</Message></Error></Errors>'
+                   '<RequestID>?</RequestID></Response>' % (code, message))
+        self.finish()
-- 
cgit 


From be2b529a987627bf454f7343df74d4e8ae670761 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 30 Aug 2010 19:08:22 -0400
Subject: Move APIRequest into its own file

---
 nova/api/ec2/apirequest.py | 132 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 132 insertions(+)
 create mode 100644 nova/api/ec2/apirequest.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
new file mode 100644
index 000000000..1fc84248b
--- /dev/null
+++ b/nova/api/ec2/apirequest.py
@@ -0,0 +1,132 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequest class
+"""
+
+# TODO(termie): replace minidom with etree
+from xml.dom import minidom
+
+from twisted.internet import defer
+
+
+_c2u = re.compile('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
+
+
+def _camelcase_to_underscore(str):
+    return _c2u.sub(r'_\1', str).lower().strip('_')
+
+
+def _underscore_to_camelcase(str):
+    return ''.join([x[:1].upper() + x[1:] for x in str.split('_')])
+
+
+def _underscore_to_xmlcase(str):
+    res = _underscore_to_camelcase(str)
+    return res[:1].lower() + res[1:]
+
+
+class APIRequest(object):
+    def __init__(self, controller, action):
+        self.controller = controller
+        self.action = action
+
+    def send(self, context, **kwargs):
+
+        try:
+            method = getattr(self.controller,
+                             _camelcase_to_underscore(self.action))
+        except AttributeError:
+            _error = ('Unsupported API request: controller = %s,'
+                      'action = %s') % (self.controller, self.action)
+            _log.warning(_error)
+            # TODO: Raise custom exception, trap in apiserver,
+            #       and reraise as 400 error.
+            raise Exception(_error)
+
+        args = {}
+        for key, value in kwargs.items():
+            parts = key.split(".")
+            key = _camelcase_to_underscore(parts[0])
+            if len(parts) > 1:
+                d = args.get(key, {})
+                d[parts[1]] = value[0]
+                value = d
+            else:
+                value = value[0]
+            args[key] = value
+
+        for key in args.keys():
+            if isinstance(args[key], dict):
+                if args[key] != {} and args[key].keys()[0].isdigit():
+                    s = args[key].items()
+                    s.sort()
+                    args[key] = [v for k, v in s]
+
+        d = defer.maybeDeferred(method, context, **args)
+        d.addCallback(self._render_response, context.request_id)
+        return d
+
+    def _render_response(self, response_data, request_id):
+        xml = minidom.Document()
+
+        response_el = xml.createElement(self.action + 'Response')
+        response_el.setAttribute('xmlns',
+                                 'http://ec2.amazonaws.com/doc/2009-11-30/')
+        request_id_el = xml.createElement('requestId')
+        request_id_el.appendChild(xml.createTextNode(request_id))
+        response_el.appendChild(request_id_el)
+        if(response_data == True):
+            self._render_dict(xml, response_el, {'return': 'true'})
+        else:
+            self._render_dict(xml, response_el, response_data)
+
+        xml.appendChild(response_el)
+
+        response = xml.toxml()
+        xml.unlink()
+        _log.debug(response)
+        return response
+
+    def _render_dict(self, xml, el, data):
+        try:
+            for key in data.keys():
+                val = data[key]
+                el.appendChild(self._render_data(xml, key, val))
+        except:
+            _log.debug(data)
+            raise
+
+    def _render_data(self, xml, el_name, data):
+        el_name = _underscore_to_xmlcase(el_name)
+        data_el = xml.createElement(el_name)
+
+        if isinstance(data, list):
+            for item in data:
+                data_el.appendChild(self._render_data(xml, 'item', item))
+        elif isinstance(data, dict):
+            self._render_dict(xml, data_el, data)
+        elif hasattr(data, '__dict__'):
+            self._render_dict(xml, data_el, data.__dict__)
+        elif isinstance(data, bool):
+            data_el.appendChild(xml.createTextNode(str(data).lower()))
+        elif data != None:
+            data_el.appendChild(xml.createTextNode(str(data)))
+
+        return data_el
-- 
cgit 


From 4bca41506c90e779a8d4a5defdca3add79073185 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 30 Aug 2010 19:10:17 -0400
Subject: Move APIRequestContext into its own file

---
 nova/api/ec2/apirequestcontext.py | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 nova/api/ec2/apirequestcontext.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/apirequestcontext.py b/nova/api/ec2/apirequestcontext.py
new file mode 100644
index 000000000..fb3118020
--- /dev/null
+++ b/nova/api/ec2/apirequestcontext.py
@@ -0,0 +1,33 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequestContext
+"""
+
+import random
+
+class APIRequestContext(object):
+    def __init__(self, handler, user, project):
+        self.handler = handler
+        self.user = user
+        self.project = project
+        self.request_id = ''.join(
+                [random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-')
+                 for x in xrange(20)]
+                )
-- 
cgit 


From 1ef59040aa1304a4682c6bcdaa3333372e7f8629 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 30 Aug 2010 19:12:31 -0400
Subject: Delete __init__.py in prep for turning apirequesthandler into
 __init__

---
 nova/api/ec2/__init__.py | 42 ------------------------------------------
 1 file changed, 42 deletions(-)
 delete mode 100644 nova/api/ec2/__init__.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
deleted file mode 100644
index 6eec0abf7..000000000
--- a/nova/api/ec2/__init__.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-WSGI middleware for EC2 API controllers.
-"""
-
-import routes
-import webob.dec
-
-from nova import wsgi
-
-
-class API(wsgi.Router):
-    """Routes EC2 requests to the appropriate controller."""
-
-    def __init__(self):
-        mapper = routes.Mapper()
-        mapper.connect(None, "{all:.*}", controller=self.dummy)
-        super(API, self).__init__(mapper)
-
-    @staticmethod
-    @webob.dec.wsgify
-    def dummy(req):
-        """Temporary dummy controller."""
-        msg = "dummy response -- please hook up __init__() to cloud.py instead"
-        return repr({'dummy': msg,
-                     'kwargs': repr(req.environ['wsgiorg.routing_args'][1])})
-- 
cgit 


From c54d6c3d1fcb0210e9f52097f1a1e85550c84bf6 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 31 Aug 2010 10:03:51 -0400
Subject: First steps in reworking EC2 APIRequestHandler into separate
 Authenticate() and Router() WSGI apps

---
 nova/api/__init__.py              |   4 +
 nova/api/ec2/__init__.py          | 151 ++++++++++++++++++++++++++++++++++++++
 nova/api/ec2/apirequesthandler.py | 126 -------------------------------
 3 files changed, 155 insertions(+), 126 deletions(-)
 create mode 100644 nova/api/ec2/__init__.py
 delete mode 100644 nova/api/ec2/apirequesthandler.py

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index b9b9e3988..0166b7fc1 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -32,6 +32,10 @@ class API(wsgi.Router):
 
     def __init__(self):
         mapper = routes.Mapper()
+        # TODO(gundlach): EC2 RootController is replaced by this class;
+        # MetadataRequestHandlers isn't part of the EC2 API and thus can
+        # be dropped; and I'm leaving off CloudPipeRequestHandler until
+        # I hear that we need it.
         mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API())
         mapper.connect("/ec2/{path_info:.*}", controller=ec2.API())
         super(API, self).__init__(mapper)
diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
new file mode 100644
index 000000000..a4d9b95f9
--- /dev/null
+++ b/nova/api/ec2/__init__.py
@@ -0,0 +1,151 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Starting point for routing EC2 requests
+"""
+
+import logging
+import routes
+import webob.exc
+from webob.dec import wsgify
+
+from nova.api.ec2 import admin
+from nova.api.ec2 import cloud
+from nova import exception
+from nova import utils
+from nova.auth import manager
+
+
+_log = logging.getLogger("api")
+_log.setLevel(logging.DEBUG)
+
+
+class API(wsgi.Middleware):
+    """Routing for all EC2 API requests."""
+
+    def __init__(self):
+        self.application = Authenticate(Router())
+
+class Authenticate(wsgi.Middleware):
+    """Authenticates an EC2 request."""
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        #TODO(gundlach): where do arguments come from?
+        args = self.request.arguments
+
+        # Read request signature.
+        try:
+            signature = args.pop('Signature')[0]
+        except:
+            raise webob.exc.HTTPBadRequest()
+
+        # Make a copy of args for authentication and signature verification.
+        auth_params = {}
+        for key, value in args.items():
+            auth_params[key] = value[0]
+
+        # Get requested action and remove authentication args for final request.
+        try:
+            action = args.pop('Action')[0]
+            access = args.pop('AWSAccessKeyId')[0]
+            args.pop('SignatureMethod')
+            args.pop('SignatureVersion')
+            args.pop('Version')
+            args.pop('Timestamp')
+        except:
+            raise webob.exc.HTTPBadRequest()
+
+        # Authenticate the request.
+        try:
+            (user, project) = manager.AuthManager().authenticate(
+                access,
+                signature,
+                auth_params,
+                req.method,
+                req.host,
+                req.path
+            )
+
+        except exception.Error, ex:
+            logging.debug("Authentication Failure: %s" % ex)
+            raise webob.exc.HTTPForbidden()
+
+        _log.debug('action: %s' % action)
+
+        for key, value in args.items():
+            _log.debug('arg: %s\t\tval: %s' % (key, value))
+
+        # Authenticated!
+        req.environ['ec2.action'] = action
+        req.environ['ec2.context'] = APIRequestContext(user, project)
+        return self.application
+
+
+class Router(wsgi.Application):
+    """
+    Finds controller for a request, executes environ['ec2.action'] upon it, and
+    returns a response.
+    """
+    def __init__(self):
+        self.map = routes.Mapper()
+        self.map.connect("/{controller_name}/")
+        self.controllers = dict(Cloud=cloud.CloudController(),
+                                Admin=admin.AdminController())
+
+    def __call__(self, req):
+        # Obtain the appropriate controller for this request.
+        match = self.map.match(req.path)
+        if not match:
+            raise webob.exc.HTTPNotFound()
+        controller_name = match['controller_name']
+
+        try:
+            controller = self.controllers[controller_name]
+        except KeyError:
+            self._error('unhandled', 'no controller named %s' % controller_name)
+            return
+
+        request = APIRequest(controller, req.environ['ec2.action'])
+        context = req.environ['ec2.context']
+        try:
+            data = request.send(context, **args)
+            req.headers['Content-Type'] = 'text/xml'
+            return data
+        #TODO(gundlach) under what conditions would _error_callbock used to
+        #be called?  What was 'failure' that you could call .raiseException
+        #on it?
+        except Exception, ex:
+            try:
+                #TODO
+                failure.raiseException()
+            except exception.ApiError as ex:
+                self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
+            # TODO(vish): do something more useful with unknown exceptions
+            except Exception as ex:
+                self._error(type(ex).__name__, str(ex))
+
+    def _error(self, req, code, message):
+        req.status = 400
+        req.headers['Content-Type'] = 'text/xml'
+        req.response = ('<?xml version="1.0"?>\n'
+                     '<Response><Errors><Error><Code>%s</Code>'
+                     '<Message>%s</Message></Error></Errors>'
+                     '<RequestID>?</RequestID></Response>') % (code, message))
+
diff --git a/nova/api/ec2/apirequesthandler.py b/nova/api/ec2/apirequesthandler.py
deleted file mode 100644
index bbba60c02..000000000
--- a/nova/api/ec2/apirequesthandler.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-APIRequestHandler, pulled unmodified out of nova.endpoint.api
-"""
-
-import logging
-
-import tornado.web
-
-from nova import exception
-from nova import utils
-from nova.auth import manager
-
-
-_log = logging.getLogger("api")
-_log.setLevel(logging.DEBUG)
-
-
-class APIRequestHandler(tornado.web.RequestHandler):
-    def get(self, controller_name):
-        self.execute(controller_name)
-
-    @tornado.web.asynchronous
-    def execute(self, controller_name):
-        # Obtain the appropriate controller for this request.
-        try:
-            controller = self.application.controllers[controller_name]
-        except KeyError:
-            self._error('unhandled', 'no controller named %s' % controller_name)
-            return
-
-        args = self.request.arguments
-
-        # Read request signature.
-        try:
-            signature = args.pop('Signature')[0]
-        except:
-            raise tornado.web.HTTPError(400)
-
-        # Make a copy of args for authentication and signature verification.
-        auth_params = {}
-        for key, value in args.items():
-            auth_params[key] = value[0]
-
-        # Get requested action and remove authentication args for final request.
-        try:
-            action = args.pop('Action')[0]
-            access = args.pop('AWSAccessKeyId')[0]
-            args.pop('SignatureMethod')
-            args.pop('SignatureVersion')
-            args.pop('Version')
-            args.pop('Timestamp')
-        except:
-            raise tornado.web.HTTPError(400)
-
-        # Authenticate the request.
-        try:
-            (user, project) = manager.AuthManager().authenticate(
-                access,
-                signature,
-                auth_params,
-                self.request.method,
-                self.request.host,
-                self.request.path
-            )
-
-        except exception.Error, ex:
-            logging.debug("Authentication Failure: %s" % ex)
-            raise tornado.web.HTTPError(403)
-
-        _log.debug('action: %s' % action)
-
-        for key, value in args.items():
-            _log.debug('arg: %s\t\tval: %s' % (key, value))
-
-        request = APIRequest(controller, action)
-        context = APIRequestContext(self, user, project)
-        d = request.send(context, **args)
-        # d.addCallback(utils.debug)
-
-        # TODO: Wrap response in AWS XML format
-        d.addCallbacks(self._write_callback, self._error_callback)
-
-    def _write_callback(self, data):
-        self.set_header('Content-Type', 'text/xml')
-        self.write(data)
-        self.finish()
-
-    def _error_callback(self, failure):
-        try:
-            failure.raiseException()
-        except exception.ApiError as ex:
-            self._error(type(ex).__name__ + "." + ex.code, ex.message)
-        # TODO(vish): do something more useful with unknown exceptions
-        except Exception as ex:
-            self._error(type(ex).__name__, str(ex))
-            raise
-
-    def post(self, controller_name):
-        self.execute(controller_name)
-
-    def _error(self, code, message):
-        self._status_code = 400
-        self.set_header('Content-Type', 'text/xml')
-        self.write('<?xml version="1.0"?>\n')
-        self.write('<Response><Errors><Error><Code>%s</Code>'
-                   '<Message>%s</Message></Error></Errors>'
-                   '<RequestID>?</RequestID></Response>' % (code, message))
-        self.finish()
-- 
cgit 


From 070d87df264ca949b51131df9287fbcee373d480 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 31 Aug 2010 10:46:01 -0400
Subject: Get rid of some convoluted exception handling that we don't need in
 eventlet

---
 nova/api/ec2/__init__.py   | 23 +++++++----------------
 nova/api/ec2/apirequest.py |  7 ++++---
 2 files changed, 11 insertions(+), 19 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index a4d9b95f9..46e543d0e 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -122,24 +122,15 @@ class Router(wsgi.Application):
             self._error('unhandled', 'no controller named %s' % controller_name)
             return
 
-        request = APIRequest(controller, req.environ['ec2.action'])
+        api_request = APIRequest(controller, req.environ['ec2.action'])
         context = req.environ['ec2.context']
         try:
-            data = request.send(context, **args)
-            req.headers['Content-Type'] = 'text/xml'
-            return data
-        #TODO(gundlach) under what conditions would _error_callbock used to
-        #be called?  What was 'failure' that you could call .raiseException
-        #on it?
-        except Exception, ex:
-            try:
-                #TODO
-                failure.raiseException()
-            except exception.ApiError as ex:
-                self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
-            # TODO(vish): do something more useful with unknown exceptions
-            except Exception as ex:
-                self._error(type(ex).__name__, str(ex))
+            return api_request.send(context, **args)
+        except exception.ApiError as ex:
+            self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
+        # TODO(vish): do something more useful with unknown exceptions
+        except Exception as ex:
+            self._error(type(ex).__name__, str(ex))
 
     def _error(self, req, code, message):
         req.status = 400
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index 1fc84248b..77f1a7759 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -79,9 +79,10 @@ class APIRequest(object):
                     s.sort()
                     args[key] = [v for k, v in s]
 
-        d = defer.maybeDeferred(method, context, **args)
-        d.addCallback(self._render_response, context.request_id)
-        return d
+        result = method(context, **args)
+
+        req.headers['Content-Type'] = 'text/xml'
+        return self._render_response(result, context.request_id)
 
     def _render_response(self, response_data, request_id):
         xml = minidom.Document()
-- 
cgit 


From cb55d65827170dd9d54dbd22f32e5c2171f8e1b1 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 31 Aug 2010 10:55:53 -0400
Subject: small import cleanup

---
 nova/api/ec2/__init__.py   | 5 ++---
 nova/api/ec2/apirequest.py | 2 --
 2 files changed, 2 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 46e543d0e..7e345d297 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -22,13 +22,12 @@ Starting point for routing EC2 requests
 
 import logging
 import routes
+import webob.dec
 import webob.exc
-from webob.dec import wsgify
 
 from nova.api.ec2 import admin
 from nova.api.ec2 import cloud
 from nova import exception
-from nova import utils
 from nova.auth import manager
 
 
@@ -101,7 +100,7 @@ class Authenticate(wsgi.Middleware):
 class Router(wsgi.Application):
     """
     Finds controller for a request, executes environ['ec2.action'] upon it, and
-    returns a response.
+    returns an XML response.  If the action fails, returns a 400.
     """
     def __init__(self):
         self.map = routes.Mapper()
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index 77f1a7759..261346a09 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -23,8 +23,6 @@ APIRequest class
 # TODO(termie): replace minidom with etree
 from xml.dom import minidom
 
-from twisted.internet import defer
-
 
 _c2u = re.compile('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
 
-- 
cgit 


From ab43c28e583116c4885b19afc6448192aae10096 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 31 Aug 2010 12:15:29 -0400
Subject: Move cloudcontroller and admincontroller into new api

---
 nova/api/ec2/admin.py | 211 ++++++++++++++
 nova/api/ec2/cloud.py | 739 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 950 insertions(+)
 create mode 100644 nova/api/ec2/admin.py
 create mode 100644 nova/api/ec2/cloud.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
new file mode 100644
index 000000000..d6f622755
--- /dev/null
+++ b/nova/api/ec2/admin.py
@@ -0,0 +1,211 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Admin API controller, exposed through http via the api worker.
+"""
+
+import base64
+
+from nova.auth import manager
+from nova.compute import model
+
+
+def user_dict(user, base64_file=None):
+    """Convert the user object to a result dict"""
+    if user:
+        return {
+            'username': user.id,
+            'accesskey': user.access,
+            'secretkey': user.secret,
+            'file': base64_file}
+    else:
+        return {}
+
+
+def project_dict(project):
+    """Convert the project object to a result dict"""
+    if project:
+        return {
+            'projectname': project.id,
+            'project_manager_id': project.project_manager_id,
+            'description': project.description}
+    else:
+        return {}
+
+
+def host_dict(host):
+    """Convert a host model object to a result dict"""
+    if host:
+        return host.state
+    else:
+        return {}
+
+
+def admin_only(target):
+    """Decorator for admin-only API calls"""
+    def wrapper(*args, **kwargs):
+        """Internal wrapper method for admin-only API calls"""
+        context = args[1]
+        if context.user.is_admin():
+            return target(*args, **kwargs)
+        else:
+            return {}
+
+    return wrapper
+
+
+class AdminController(object):
+    """
+    API Controller for users, hosts, nodes, and workers.
+    Trivial admin_only wrapper will be replaced with RBAC,
+    allowing project managers to administer project users.
+    """
+
+    def __str__(self):
+        return 'AdminController'
+
+    @admin_only
+    def describe_user(self, _context, name, **_kwargs):
+        """Returns user data, including access and secret keys."""
+        return user_dict(manager.AuthManager().get_user(name))
+
+    @admin_only
+    def describe_users(self, _context, **_kwargs):
+        """Returns all users - should be changed to deal with a list."""
+        return {'userSet':
+            [user_dict(u) for u in manager.AuthManager().get_users()] }
+
+    @admin_only
+    def register_user(self, _context, name, **_kwargs):
+        """Creates a new user, and returns generated credentials."""
+        return user_dict(manager.AuthManager().create_user(name))
+
+    @admin_only
+    def deregister_user(self, _context, name, **_kwargs):
+        """Deletes a single user (NOT undoable.)
+           Should throw an exception if the user has instances,
+           volumes, or buckets remaining.
+        """
+        manager.AuthManager().delete_user(name)
+
+        return True
+
+    @admin_only
+    def describe_roles(self, context, project_roles=True, **kwargs):
+        """Returns a list of allowed roles."""
+        roles = manager.AuthManager().get_roles(project_roles)
+        return { 'roles': [{'role': r} for r in roles]}
+
+    @admin_only
+    def describe_user_roles(self, context, user, project=None, **kwargs):
+        """Returns a list of roles for the given user.
+           Omitting project will return any global roles that the user has.
+           Specifying project will return only project specific roles.
+        """
+        roles = manager.AuthManager().get_user_roles(user, project=project)
+        return { 'roles': [{'role': r} for r in roles]}
+
+    @admin_only
+    def modify_user_role(self, context, user, role, project=None,
+                         operation='add', **kwargs):
+        """Add or remove a role for a user and project."""
+        if operation == 'add':
+            manager.AuthManager().add_role(user, role, project)
+        elif operation == 'remove':
+            manager.AuthManager().remove_role(user, role, project)
+        else:
+            raise exception.ApiError('operation must be add or remove')
+
+        return True
+
+    @admin_only
+    def generate_x509_for_user(self, _context, name, project=None, **kwargs):
+        """Generates and returns an x509 certificate for a single user.
+           Is usually called from a client that will wrap this with
+           access and secret key info, and return a zip file.
+        """
+        if project is None:
+            project = name
+        project = manager.AuthManager().get_project(project)
+        user = manager.AuthManager().get_user(name)
+        return user_dict(user, base64.b64encode(project.get_credentials(user)))
+
+    @admin_only
+    def describe_project(self, context, name, **kwargs):
+        """Returns project data, including member ids."""
+        return project_dict(manager.AuthManager().get_project(name))
+
+    @admin_only
+    def describe_projects(self, context, user=None, **kwargs):
+        """Returns all projects - should be changed to deal with a list."""
+        return {'projectSet':
+            [project_dict(u) for u in
+            manager.AuthManager().get_projects(user=user)]}
+
+    @admin_only
+    def register_project(self, context, name, manager_user, description=None,
+                         member_users=None, **kwargs):
+        """Creates a new project"""
+        return project_dict(
+            manager.AuthManager().create_project(
+                name,
+                manager_user,
+                description=None,
+                member_users=None))
+
+    @admin_only
+    def deregister_project(self, context, name):
+        """Permanently deletes a project."""
+        manager.AuthManager().delete_project(name)
+        return True
+
+    @admin_only
+    def describe_project_members(self, context, name, **kwargs):
+        project = manager.AuthManager().get_project(name)
+        result = {
+            'members': [{'member': m} for m in project.member_ids]}
+        return result
+        
+    @admin_only
+    def modify_project_member(self, context, user, project, operation, **kwargs):
+        """Add or remove a user from a project."""
+        if operation =='add':
+            manager.AuthManager().add_to_project(user, project)
+        elif operation == 'remove':
+            manager.AuthManager().remove_from_project(user, project)
+        else:
+            raise exception.ApiError('operation must be add or remove')
+        return True
+
+    @admin_only
+    def describe_hosts(self, _context, **_kwargs):
+        """Returns status info for all nodes. Includes:
+            * Disk Space
+            * Instance List
+            * RAM used
+            * CPU used
+            * DHCP servers running
+            * Iptables / bridges
+        """
+        return {'hostSet': [host_dict(h) for h in model.Host.all()]}
+
+    @admin_only
+    def describe_host(self, _context, name, **_kwargs):
+        """Returns status info for single node."""
+        return host_dict(model.Host.lookup(name))
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
new file mode 100644
index 000000000..30634429d
--- /dev/null
+++ b/nova/api/ec2/cloud.py
@@ -0,0 +1,739 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Cloud Controller: Implementation of EC2 REST API calls, which are
+dispatched to other nodes via AMQP RPC. State is via distributed
+datastore.
+"""
+
+import base64
+import logging
+import os
+import time
+
+from twisted.internet import defer
+
+from nova import datastore
+from nova import exception
+from nova import flags
+from nova import rpc
+from nova import utils
+from nova.auth import rbac
+from nova.auth import manager
+from nova.compute import model
+from nova.compute.instance_types import INSTANCE_TYPES
+from nova.endpoint import images
+from nova.network import service as network_service
+from nova.network import model as network_model
+from nova.volume import service
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('cloud_topic', 'cloud', 'the topic clouds listen on')
+
+
+def _gen_key(user_id, key_name):
+    """ Tuck this into AuthManager """
+    try:
+        mgr = manager.AuthManager()
+        private_key, fingerprint = mgr.generate_key_pair(user_id, key_name)
+    except Exception as ex:
+        return {'exception': ex}
+    return {'private_key': private_key, 'fingerprint': fingerprint}
+
+
+class CloudController(object):
+    """ CloudController provides the critical dispatch between
+ inbound API calls through the endpoint and messages
+ sent to the other nodes.
+"""
+    def __init__(self):
+        self.instdir = model.InstanceDirectory()
+        self.setup()
+
+    @property
+    def instances(self):
+        """ All instances in the system, as dicts """
+        return self.instdir.all
+
+    @property
+    def volumes(self):
+        """ returns a list of all volumes """
+        for volume_id in datastore.Redis.instance().smembers("volumes"):
+            volume = service.get_volume(volume_id)
+            yield volume
+
+    def __str__(self):
+        return 'CloudController'
+
+    def setup(self):
+        """ Ensure the keychains and folders exist. """
+        # Create keys folder, if it doesn't exist
+        if not os.path.exists(FLAGS.keys_path):
+            os.makedirs(FLAGS.keys_path)
+        # Gen root CA, if we don't have one
+        root_ca_path = os.path.join(FLAGS.ca_path, FLAGS.ca_file)
+        if not os.path.exists(root_ca_path):
+            start = os.getcwd()
+            os.chdir(FLAGS.ca_path)
+            utils.runthis("Generating root CA: %s", "sh genrootca.sh")
+            os.chdir(start)
+            # TODO: Do this with M2Crypto instead
+
+    def get_instance_by_ip(self, ip):
+        return self.instdir.by_ip(ip)
+
+    def _get_mpi_data(self, project_id):
+        result = {}
+        for instance in self.instdir.all:
+            if instance['project_id'] == project_id:
+                line = '%s slots=%d' % (instance['private_dns_name'],
+                    INSTANCE_TYPES[instance['instance_type']]['vcpus'])
+                if instance['key_name'] in result:
+                    result[instance['key_name']].append(line)
+                else:
+                    result[instance['key_name']] = [line]
+        return result
+
+    def get_metadata(self, ipaddress):
+        i = self.get_instance_by_ip(ipaddress)
+        if i is None:
+            return None
+        mpi = self._get_mpi_data(i['project_id'])
+        if i['key_name']:
+            keys = {
+                '0': {
+                    '_name': i['key_name'],
+                    'openssh-key': i['key_data']
+                }
+            }
+        else:
+            keys = ''
+
+        address_record = network_model.FixedIp(i['private_dns_name'])
+        if address_record:
+            hostname = address_record['hostname']
+        else:
+            hostname = 'ip-%s' % i['private_dns_name'].replace('.', '-')
+        data = {
+            'user-data': base64.b64decode(i['user_data']),
+            'meta-data': {
+                'ami-id': i['image_id'],
+                'ami-launch-index': i['ami_launch_index'],
+                'ami-manifest-path': 'FIXME', # image property
+                'block-device-mapping': { # TODO: replace with real data
+                    'ami': 'sda1',
+                    'ephemeral0': 'sda2',
+                    'root': '/dev/sda1',
+                    'swap': 'sda3'
+                },
+                'hostname': hostname,
+                'instance-action': 'none',
+                'instance-id': i['instance_id'],
+                'instance-type': i.get('instance_type', ''),
+                'local-hostname': hostname,
+                'local-ipv4': i['private_dns_name'], # TODO: switch to IP
+                'kernel-id': i.get('kernel_id', ''),
+                'placement': {
+                    'availaibility-zone': i.get('availability_zone', 'nova'),
+                },
+                'public-hostname': hostname,
+                'public-ipv4': i.get('dns_name', ''), # TODO: switch to IP
+                'public-keys': keys,
+                'ramdisk-id': i.get('ramdisk_id', ''),
+                'reservation-id': i['reservation_id'],
+                'security-groups': i.get('groups', ''),
+                'mpi': mpi
+            }
+        }
+        if False: # TODO: store ancestor ids
+            data['ancestor-ami-ids'] = []
+        if i.get('product_codes', None):
+            data['product-codes'] = i['product_codes']
+        return data
+
+    @rbac.allow('all')
+    def describe_availability_zones(self, context, **kwargs):
+        return {'availabilityZoneInfo': [{'zoneName': 'nova',
+                                          'zoneState': 'available'}]}
+
+    @rbac.allow('all')
+    def describe_regions(self, context, region_name=None, **kwargs):
+        # TODO(vish): region_name is an array.  Support filtering
+        return {'regionInfo': [{'regionName': 'nova',
+                                'regionUrl': FLAGS.ec2_url}]}
+
+    @rbac.allow('all')
+    def describe_snapshots(self,
+                           context,
+                           snapshot_id=None,
+                           owner=None,
+                           restorable_by=None,
+                           **kwargs):
+        return {'snapshotSet': [{'snapshotId': 'fixme',
+                                 'volumeId': 'fixme',
+                                 'status': 'fixme',
+                                 'startTime': 'fixme',
+                                 'progress': 'fixme',
+                                 'ownerId': 'fixme',
+                                 'volumeSize': 0,
+                                 'description': 'fixme'}]}
+
+    @rbac.allow('all')
+    def describe_key_pairs(self, context, key_name=None, **kwargs):
+        key_pairs = context.user.get_key_pairs()
+        if not key_name is None:
+            key_pairs = [x for x in key_pairs if x.name in key_name]
+
+        result = []
+        for key_pair in key_pairs:
+            # filter out the vpn keys
+            suffix = FLAGS.vpn_key_suffix
+            if context.user.is_admin() or not key_pair.name.endswith(suffix):
+                result.append({
+                    'keyName': key_pair.name,
+                    'keyFingerprint': key_pair.fingerprint,
+                })
+
+        return {'keypairsSet': result}
+
+    @rbac.allow('all')
+    def create_key_pair(self, context, key_name, **kwargs):
+        dcall = defer.Deferred()
+        pool = context.handler.application.settings.get('pool')
+        def _complete(kwargs):
+            if 'exception' in kwargs:
+                dcall.errback(kwargs['exception'])
+                return
+            dcall.callback({'keyName': key_name,
+                'keyFingerprint': kwargs['fingerprint'],
+                'keyMaterial': kwargs['private_key']})
+        pool.apply_async(_gen_key, [context.user.id, key_name],
+            callback=_complete)
+        return dcall
+
+    @rbac.allow('all')
+    def delete_key_pair(self, context, key_name, **kwargs):
+        context.user.delete_key_pair(key_name)
+        # aws returns true even if the key doens't exist
+        return True
+
+    @rbac.allow('all')
+    def describe_security_groups(self, context, group_names, **kwargs):
+        groups = {'securityGroupSet': []}
+
+        # Stubbed for now to unblock other things.
+        return groups
+
+    @rbac.allow('netadmin')
+    def create_security_group(self, context, group_name, **kwargs):
+        return True
+
+    @rbac.allow('netadmin')
+    def delete_security_group(self, context, group_name, **kwargs):
+        return True
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def get_console_output(self, context, instance_id, **kwargs):
+        # instance_id is passed in as a list of instances
+        instance = self._get_instance(context, instance_id[0])
+        return rpc.call('%s.%s' % (FLAGS.compute_topic, instance['node_name']),
+            {"method": "get_console_output",
+             "args": {"instance_id": instance_id[0]}})
+
+    def _get_user_id(self, context):
+        if context and context.user:
+            return context.user.id
+        else:
+            return None
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def describe_volumes(self, context, **kwargs):
+        volumes = []
+        for volume in self.volumes:
+            if context.user.is_admin() or volume['project_id'] == context.project.id:
+                v = self.format_volume(context, volume)
+                volumes.append(v)
+        return defer.succeed({'volumeSet': volumes})
+
+    def format_volume(self, context, volume):
+        v = {}
+        v['volumeId'] = volume['volume_id']
+        v['status'] = volume['status']
+        v['size'] = volume['size']
+        v['availabilityZone'] = volume['availability_zone']
+        v['createTime'] = volume['create_time']
+        if context.user.is_admin():
+            v['status'] = '%s (%s, %s, %s, %s)' % (
+                volume.get('status', None),
+                volume.get('user_id', None),
+                volume.get('node_name', None),
+                volume.get('instance_id', ''),
+                volume.get('mountpoint', ''))
+        if volume['attach_status'] == 'attached':
+            v['attachmentSet'] = [{'attachTime': volume['attach_time'],
+                                   'deleteOnTermination': volume['delete_on_termination'],
+                                   'device': volume['mountpoint'],
+                                   'instanceId': volume['instance_id'],
+                                   'status': 'attached',
+                                   'volume_id': volume['volume_id']}]
+        else:
+            v['attachmentSet'] = [{}]
+        return v
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    @defer.inlineCallbacks
+    def create_volume(self, context, size, **kwargs):
+        # TODO(vish): refactor this to create the volume object here and tell service to create it
+        result = yield rpc.call(FLAGS.volume_topic, {"method": "create_volume",
+                                 "args": {"size": size,
+                                           "user_id": context.user.id,
+                                           "project_id": context.project.id}})
+        # NOTE(vish): rpc returned value is in the result key in the dictionary
+        volume = self._get_volume(context, result)
+        defer.returnValue({'volumeSet': [self.format_volume(context, volume)]})
+
+    def _get_address(self, context, public_ip):
+        # FIXME(vish) this should move into network.py
+        address = network_model.ElasticIp.lookup(public_ip)
+        if address and (context.user.is_admin() or address['project_id'] == context.project.id):
+            return address
+        raise exception.NotFound("Address at ip %s not found" % public_ip)
+
+    def _get_image(self, context, image_id):
+        """passes in context because
+        objectstore does its own authorization"""
+        result = images.list(context, [image_id])
+        if not result:
+            raise exception.NotFound('Image %s could not be found' % image_id)
+        image = result[0]
+        return image
+
+    def _get_instance(self, context, instance_id):
+        for instance in self.instdir.all:
+            if instance['instance_id'] == instance_id:
+                if context.user.is_admin() or instance['project_id'] == context.project.id:
+                    return instance
+        raise exception.NotFound('Instance %s could not be found' % instance_id)
+
+    def _get_volume(self, context, volume_id):
+        volume = service.get_volume(volume_id)
+        if context.user.is_admin() or volume['project_id'] == context.project.id:
+            return volume
+        raise exception.NotFound('Volume %s could not be found' % volume_id)
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
+        volume = self._get_volume(context, volume_id)
+        if volume['status'] == "attached":
+            raise exception.ApiError("Volume is already attached")
+        # TODO(vish): looping through all volumes is slow. We should probably maintain an index
+        for vol in self.volumes:
+            if vol['instance_id'] == instance_id and vol['mountpoint'] == device:
+                raise exception.ApiError("Volume %s is already attached to %s" % (vol['volume_id'], vol['mountpoint']))
+        volume.start_attach(instance_id, device)
+        instance = self._get_instance(context, instance_id)
+        compute_node = instance['node_name']
+        rpc.cast('%s.%s' % (FLAGS.compute_topic, compute_node),
+                                {"method": "attach_volume",
+                                 "args": {"volume_id": volume_id,
+                                           "instance_id": instance_id,
+                                           "mountpoint": device}})
+        return defer.succeed({'attachTime': volume['attach_time'],
+                              'device': volume['mountpoint'],
+                              'instanceId': instance_id,
+                              'requestId': context.request_id,
+                              'status': volume['attach_status'],
+                              'volumeId': volume_id})
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def detach_volume(self, context, volume_id, **kwargs):
+        volume = self._get_volume(context, volume_id)
+        instance_id = volume.get('instance_id', None)
+        if not instance_id:
+            raise exception.Error("Volume isn't attached to anything!")
+        if volume['status'] == "available":
+            raise exception.Error("Volume is already detached")
+        try:
+            volume.start_detach()
+            instance = self._get_instance(context, instance_id)
+            rpc.cast('%s.%s' % (FLAGS.compute_topic, instance['node_name']),
+                                {"method": "detach_volume",
+                                 "args": {"instance_id": instance_id,
+                                           "volume_id": volume_id}})
+        except exception.NotFound:
+            # If the instance doesn't exist anymore,
+            # then we need to call detach blind
+            volume.finish_detach()
+        return defer.succeed({'attachTime': volume['attach_time'],
+                              'device': volume['mountpoint'],
+                              'instanceId': instance_id,
+                              'requestId': context.request_id,
+                              'status': volume['attach_status'],
+                              'volumeId': volume_id})
+
+    def _convert_to_set(self, lst, label):
+        if lst == None or lst == []:
+            return None
+        if not isinstance(lst, list):
+            lst = [lst]
+        return [{label: x} for x in lst]
+
+    @rbac.allow('all')
+    def describe_instances(self, context, **kwargs):
+        return defer.succeed(self._format_describe_instances(context))
+
+    def _format_describe_instances(self, context):
+        return { 'reservationSet': self._format_instances(context) }
+
+    def _format_run_instances(self, context, reservation_id):
+        i = self._format_instances(context, reservation_id)
+        assert len(i) == 1
+        return i[0]
+
+    def _format_instances(self, context, reservation_id = None):
+        reservations = {}
+        if context.user.is_admin():
+            instgenerator = self.instdir.all
+        else:
+            instgenerator = self.instdir.by_project(context.project.id)
+        for instance in instgenerator:
+            res_id = instance.get('reservation_id', 'Unknown')
+            if reservation_id != None and reservation_id != res_id:
+                continue
+            if not context.user.is_admin():
+                if instance['image_id'] == FLAGS.vpn_image_id:
+                    continue
+            i = {}
+            i['instance_id'] = instance.get('instance_id', None)
+            i['image_id'] = instance.get('image_id', None)
+            i['instance_state'] = {
+                'code': instance.get('state', 0),
+                'name': instance.get('state_description', 'pending')
+            }
+            i['public_dns_name'] = network_model.get_public_ip_for_instance(
+                                                        i['instance_id'])
+            i['private_dns_name'] = instance.get('private_dns_name', None)
+            if not i['public_dns_name']:
+                i['public_dns_name'] = i['private_dns_name']
+            i['dns_name'] = instance.get('dns_name', None)
+            i['key_name'] = instance.get('key_name', None)
+            if context.user.is_admin():
+                i['key_name'] = '%s (%s, %s)' % (i['key_name'],
+                    instance.get('project_id', None),
+                    instance.get('node_name', ''))
+            i['product_codes_set'] = self._convert_to_set(
+                instance.get('product_codes', None), 'product_code')
+            i['instance_type'] = instance.get('instance_type', None)
+            i['launch_time'] = instance.get('launch_time', None)
+            i['ami_launch_index'] = instance.get('ami_launch_index',
+                                                 None)
+            if not reservations.has_key(res_id):
+                r = {}
+                r['reservation_id'] = res_id
+                r['owner_id'] = instance.get('project_id', None)
+                r['group_set'] = self._convert_to_set(
+                    instance.get('groups', None), 'group_id')
+                r['instances_set'] = []
+                reservations[res_id] = r
+            reservations[res_id]['instances_set'].append(i)
+
+        return list(reservations.values())
+
+    @rbac.allow('all')
+    def describe_addresses(self, context, **kwargs):
+        return self.format_addresses(context)
+
+    def format_addresses(self, context):
+        addresses = []
+        for address in network_model.ElasticIp.all():
+            # TODO(vish): implement a by_project iterator for addresses
+            if (context.user.is_admin() or
+                address['project_id'] == context.project.id):
+                address_rv = {
+                    'public_ip': address['address'],
+                    'instance_id': address.get('instance_id', 'free')
+                }
+                if context.user.is_admin():
+                    address_rv['instance_id'] = "%s (%s, %s)" % (
+                        address['instance_id'],
+                        address['user_id'],
+                        address['project_id'],
+                    )
+            addresses.append(address_rv)
+        return {'addressesSet': addresses}
+
+    @rbac.allow('netadmin')
+    @defer.inlineCallbacks
+    def allocate_address(self, context, **kwargs):
+        network_topic = yield self._get_network_topic(context)
+        public_ip = yield rpc.call(network_topic,
+                         {"method": "allocate_elastic_ip",
+                          "args": {"user_id": context.user.id,
+                                   "project_id": context.project.id}})
+        defer.returnValue({'addressSet': [{'publicIp': public_ip}]})
+
+    @rbac.allow('netadmin')
+    @defer.inlineCallbacks
+    def release_address(self, context, public_ip, **kwargs):
+        # NOTE(vish): Should we make sure this works?
+        network_topic = yield self._get_network_topic(context)
+        rpc.cast(network_topic,
+                         {"method": "deallocate_elastic_ip",
+                          "args": {"elastic_ip": public_ip}})
+        defer.returnValue({'releaseResponse': ["Address released."]})
+
+    @rbac.allow('netadmin')
+    @defer.inlineCallbacks
+    def associate_address(self, context, instance_id, public_ip, **kwargs):
+        instance = self._get_instance(context, instance_id)
+        address = self._get_address(context, public_ip)
+        network_topic = yield self._get_network_topic(context)
+        rpc.cast(network_topic,
+                         {"method": "associate_elastic_ip",
+                          "args": {"elastic_ip": address['address'],
+                                   "fixed_ip": instance['private_dns_name'],
+                                   "instance_id": instance['instance_id']}})
+        defer.returnValue({'associateResponse': ["Address associated."]})
+
+    @rbac.allow('netadmin')
+    @defer.inlineCallbacks
+    def disassociate_address(self, context, public_ip, **kwargs):
+        address = self._get_address(context, public_ip)
+        network_topic = yield self._get_network_topic(context)
+        rpc.cast(network_topic,
+                         {"method": "disassociate_elastic_ip",
+                          "args": {"elastic_ip": address['address']}})
+        defer.returnValue({'disassociateResponse': ["Address disassociated."]})
+
+    @defer.inlineCallbacks
+    def _get_network_topic(self, context):
+        """Retrieves the network host for a project"""
+        host = network_service.get_host_for_project(context.project.id)
+        if not host:
+            host = yield rpc.call(FLAGS.network_topic,
+                                    {"method": "set_network_host",
+                                     "args": {"user_id": context.user.id,
+                                              "project_id": context.project.id}})
+        defer.returnValue('%s.%s' %(FLAGS.network_topic, host))
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    @defer.inlineCallbacks
+    def run_instances(self, context, **kwargs):
+        # make sure user can access the image
+        # vpn image is private so it doesn't show up on lists
+        if kwargs['image_id'] != FLAGS.vpn_image_id:
+            image = self._get_image(context, kwargs['image_id'])
+
+        # FIXME(ja): if image is cloudpipe, this breaks
+
+        # get defaults from imagestore
+        image_id = image['imageId']
+        kernel_id = image.get('kernelId', FLAGS.default_kernel)
+        ramdisk_id = image.get('ramdiskId', FLAGS.default_ramdisk)
+
+        # API parameters overrides of defaults
+        kernel_id = kwargs.get('kernel_id', kernel_id)
+        ramdisk_id = kwargs.get('ramdisk_id', ramdisk_id)
+
+        # make sure we have access to kernel and ramdisk
+        self._get_image(context, kernel_id)
+        self._get_image(context, ramdisk_id)
+
+        logging.debug("Going to run instances...")
+        reservation_id = utils.generate_uid('r')
+        launch_time = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+        key_data = None
+        if kwargs.has_key('key_name'):
+            key_pair = context.user.get_key_pair(kwargs['key_name'])
+            if not key_pair:
+                raise exception.ApiError('Key Pair %s not found' %
+                                         kwargs['key_name'])
+            key_data = key_pair.public_key
+        network_topic = yield self._get_network_topic(context)
+        # TODO: Get the real security group of launch in here
+        security_group = "default"
+        for num in range(int(kwargs['max_count'])):
+            is_vpn = False
+            if image_id  == FLAGS.vpn_image_id:
+                is_vpn = True
+            inst = self.instdir.new()
+            allocate_data = yield rpc.call(network_topic,
+                     {"method": "allocate_fixed_ip",
+                      "args": {"user_id": context.user.id,
+                               "project_id": context.project.id,
+                               "security_group": security_group,
+                               "is_vpn": is_vpn,
+                               "hostname": inst.instance_id}})
+            inst['image_id'] = image_id
+            inst['kernel_id'] = kernel_id
+            inst['ramdisk_id'] = ramdisk_id
+            inst['user_data'] = kwargs.get('user_data', '')
+            inst['instance_type'] = kwargs.get('instance_type', 'm1.small')
+            inst['reservation_id'] = reservation_id
+            inst['launch_time'] = launch_time
+            inst['key_data'] = key_data or ''
+            inst['key_name'] = kwargs.get('key_name', '')
+            inst['user_id'] = context.user.id
+            inst['project_id'] = context.project.id
+            inst['ami_launch_index'] = num
+            inst['security_group'] = security_group
+            inst['hostname'] = inst.instance_id
+            for (key, value) in allocate_data.iteritems():
+                inst[key] = value
+
+            inst.save()
+            rpc.cast(FLAGS.compute_topic,
+                 {"method": "run_instance",
+                  "args": {"instance_id": inst.instance_id}})
+            logging.debug("Casting to node for %s's instance with IP of %s" %
+                      (context.user.name, inst['private_dns_name']))
+        # TODO: Make Network figure out the network name from ip.
+        defer.returnValue(self._format_run_instances(context, reservation_id))
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    @defer.inlineCallbacks
+    def terminate_instances(self, context, instance_id, **kwargs):
+        logging.debug("Going to start terminating instances")
+        network_topic = yield self._get_network_topic(context)
+        for i in instance_id:
+            logging.debug("Going to try and terminate %s" % i)
+            try:
+                instance = self._get_instance(context, i)
+            except exception.NotFound:
+                logging.warning("Instance %s was not found during terminate"
+                                % i)
+                continue
+            elastic_ip = network_model.get_public_ip_for_instance(i)
+            if elastic_ip:
+                logging.debug("Disassociating address %s" % elastic_ip)
+                # NOTE(vish): Right now we don't really care if the ip is
+                #             disassociated.  We may need to worry about
+                #             checking this later.  Perhaps in the scheduler?
+                rpc.cast(network_topic,
+                         {"method": "disassociate_elastic_ip",
+                          "args": {"elastic_ip": elastic_ip}})
+
+            fixed_ip = instance.get('private_dns_name', None)
+            if fixed_ip:
+                logging.debug("Deallocating address %s" % fixed_ip)
+                # NOTE(vish): Right now we don't really care if the ip is
+                #             actually removed.  We may need to worry about
+                #             checking this later.  Perhaps in the scheduler?
+                rpc.cast(network_topic,
+                         {"method": "deallocate_fixed_ip",
+                          "args": {"fixed_ip": fixed_ip}})
+
+            if instance.get('node_name', 'unassigned') != 'unassigned':
+                # NOTE(joshua?): It's also internal default
+                rpc.cast('%s.%s' % (FLAGS.compute_topic, instance['node_name']),
+                         {"method": "terminate_instance",
+                          "args": {"instance_id": i}})
+            else:
+                instance.destroy()
+        defer.returnValue(True)
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def reboot_instances(self, context, instance_id, **kwargs):
+        """instance_id is a list of instance ids"""
+        for i in instance_id:
+            instance = self._get_instance(context, i)
+            rpc.cast('%s.%s' % (FLAGS.compute_topic, instance['node_name']),
+                             {"method": "reboot_instance",
+                              "args": {"instance_id": i}})
+        return defer.succeed(True)
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def delete_volume(self, context, volume_id, **kwargs):
+        # TODO: return error if not authorized
+        volume = self._get_volume(context, volume_id)
+        volume_node = volume['node_name']
+        rpc.cast('%s.%s' % (FLAGS.volume_topic, volume_node),
+                            {"method": "delete_volume",
+                             "args": {"volume_id": volume_id}})
+        return defer.succeed(True)
+
+    @rbac.allow('all')
+    def describe_images(self, context, image_id=None, **kwargs):
+        # The objectstore does its own authorization for describe
+        imageSet = images.list(context, image_id)
+        return defer.succeed({'imagesSet': imageSet})
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def deregister_image(self, context, image_id, **kwargs):
+        # FIXME: should the objectstore be doing these authorization checks?
+        images.deregister(context, image_id)
+        return defer.succeed({'imageId': image_id})
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def register_image(self, context, image_location=None, **kwargs):
+        # FIXME: should the objectstore be doing these authorization checks?
+        if image_location is None and kwargs.has_key('name'):
+            image_location = kwargs['name']
+        image_id = images.register(context, image_location)
+        logging.debug("Registered %s as %s" % (image_location, image_id))
+
+        return defer.succeed({'imageId': image_id})
+
+    @rbac.allow('all')
+    def describe_image_attribute(self, context, image_id, attribute, **kwargs):
+        if attribute != 'launchPermission':
+            raise exception.ApiError('attribute not supported: %s' % attribute)
+        try:
+            image = images.list(context, image_id)[0]
+        except IndexError:
+            raise exception.ApiError('invalid id: %s' % image_id)
+        result = {'image_id': image_id, 'launchPermission': []}
+        if image['isPublic']:
+            result['launchPermission'].append({'group': 'all'})
+        return defer.succeed(result)
+
+    @rbac.allow('projectmanager', 'sysadmin')
+    def modify_image_attribute(self, context, image_id, attribute, operation_type, **kwargs):
+        # TODO(devcamcar): Support users and groups other than 'all'.
+        if attribute != 'launchPermission':
+            raise exception.ApiError('attribute not supported: %s' % attribute)
+        if not 'user_group' in kwargs:
+            raise exception.ApiError('user or group not specified')
+        if len(kwargs['user_group']) != 1 and kwargs['user_group'][0] != 'all':
+            raise exception.ApiError('only group "all" is supported')
+        if not operation_type in ['add', 'remove']:
+            raise exception.ApiError('operation_type must be add or remove')
+        result = images.modify(context, image_id, operation_type)
+        return defer.succeed(result)
+
+    def update_state(self, topic, value):
+        """ accepts status reports from the queue and consolidates them """
+        # TODO(jmc): if an instance has disappeared from
+        # the node, call instance_death
+        if topic == "instances":
+            return defer.succeed(True)
+        aggregate_state = getattr(self, topic)
+        node_name = value.keys()[0]
+        items = value[node_name]
+
+        logging.debug("Updating %s state for %s" % (topic, node_name))
+
+        for item_id in items.keys():
+            if (aggregate_state.has_key('pending') and
+                aggregate_state['pending'].has_key(item_id)):
+                del aggregate_state['pending'][item_id]
+        aggregate_state[node_name] = items
+
+        return defer.succeed(True)
-- 
cgit 


From 4f3bb96df8a7e48735c078520e77a47dca7a2bd1 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 31 Aug 2010 12:33:49 -0400
Subject: Remove inlineCallbacks and yield from cloud.py, as eventlet doesn't
 need it

---
 nova/api/ec2/__init__.py |  1 +
 nova/api/ec2/cloud.py    | 30 ++++++++++--------------------
 2 files changed, 11 insertions(+), 20 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 7e345d297..b4a1894cc 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -108,6 +108,7 @@ class Router(wsgi.Application):
         self.controllers = dict(Cloud=cloud.CloudController(),
                                 Admin=admin.AdminController())
 
+    @webob.dec.wsgify
     def __call__(self, req):
         # Obtain the appropriate controller for this request.
         match = self.map.match(req.path)
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 30634429d..decd2a2c0 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -27,8 +27,6 @@ import logging
 import os
 import time
 
-from twisted.internet import defer
-
 from nova import datastore
 from nova import exception
 from nova import flags
@@ -298,10 +296,9 @@ class CloudController(object):
         return v
 
     @rbac.allow('projectmanager', 'sysadmin')
-    @defer.inlineCallbacks
     def create_volume(self, context, size, **kwargs):
         # TODO(vish): refactor this to create the volume object here and tell service to create it
-        result = yield rpc.call(FLAGS.volume_topic, {"method": "create_volume",
+        result = rpc.call(FLAGS.volume_topic, {"method": "create_volume",
                                  "args": {"size": size,
                                            "user_id": context.user.id,
                                            "project_id": context.project.id}})
@@ -480,31 +477,28 @@ class CloudController(object):
         return {'addressesSet': addresses}
 
     @rbac.allow('netadmin')
-    @defer.inlineCallbacks
     def allocate_address(self, context, **kwargs):
-        network_topic = yield self._get_network_topic(context)
-        public_ip = yield rpc.call(network_topic,
+        network_topic = self._get_network_topic(context)
+        public_ip = rpc.call(network_topic,
                          {"method": "allocate_elastic_ip",
                           "args": {"user_id": context.user.id,
                                    "project_id": context.project.id}})
         defer.returnValue({'addressSet': [{'publicIp': public_ip}]})
 
     @rbac.allow('netadmin')
-    @defer.inlineCallbacks
     def release_address(self, context, public_ip, **kwargs):
         # NOTE(vish): Should we make sure this works?
-        network_topic = yield self._get_network_topic(context)
+        network_topic = self._get_network_topic(context)
         rpc.cast(network_topic,
                          {"method": "deallocate_elastic_ip",
                           "args": {"elastic_ip": public_ip}})
         defer.returnValue({'releaseResponse': ["Address released."]})
 
     @rbac.allow('netadmin')
-    @defer.inlineCallbacks
     def associate_address(self, context, instance_id, public_ip, **kwargs):
         instance = self._get_instance(context, instance_id)
         address = self._get_address(context, public_ip)
-        network_topic = yield self._get_network_topic(context)
+        network_topic = self._get_network_topic(context)
         rpc.cast(network_topic,
                          {"method": "associate_elastic_ip",
                           "args": {"elastic_ip": address['address'],
@@ -513,28 +507,25 @@ class CloudController(object):
         defer.returnValue({'associateResponse': ["Address associated."]})
 
     @rbac.allow('netadmin')
-    @defer.inlineCallbacks
     def disassociate_address(self, context, public_ip, **kwargs):
         address = self._get_address(context, public_ip)
-        network_topic = yield self._get_network_topic(context)
+        network_topic = self._get_network_topic(context)
         rpc.cast(network_topic,
                          {"method": "disassociate_elastic_ip",
                           "args": {"elastic_ip": address['address']}})
         defer.returnValue({'disassociateResponse': ["Address disassociated."]})
 
-    @defer.inlineCallbacks
     def _get_network_topic(self, context):
         """Retrieves the network host for a project"""
         host = network_service.get_host_for_project(context.project.id)
         if not host:
-            host = yield rpc.call(FLAGS.network_topic,
+            host = rpc.call(FLAGS.network_topic,
                                     {"method": "set_network_host",
                                      "args": {"user_id": context.user.id,
                                               "project_id": context.project.id}})
         defer.returnValue('%s.%s' %(FLAGS.network_topic, host))
 
     @rbac.allow('projectmanager', 'sysadmin')
-    @defer.inlineCallbacks
     def run_instances(self, context, **kwargs):
         # make sure user can access the image
         # vpn image is private so it doesn't show up on lists
@@ -566,7 +557,7 @@ class CloudController(object):
                 raise exception.ApiError('Key Pair %s not found' %
                                          kwargs['key_name'])
             key_data = key_pair.public_key
-        network_topic = yield self._get_network_topic(context)
+        network_topic = self._get_network_topic(context)
         # TODO: Get the real security group of launch in here
         security_group = "default"
         for num in range(int(kwargs['max_count'])):
@@ -574,7 +565,7 @@ class CloudController(object):
             if image_id  == FLAGS.vpn_image_id:
                 is_vpn = True
             inst = self.instdir.new()
-            allocate_data = yield rpc.call(network_topic,
+            allocate_data = rpc.call(network_topic,
                      {"method": "allocate_fixed_ip",
                       "args": {"user_id": context.user.id,
                                "project_id": context.project.id,
@@ -608,10 +599,9 @@ class CloudController(object):
         defer.returnValue(self._format_run_instances(context, reservation_id))
 
     @rbac.allow('projectmanager', 'sysadmin')
-    @defer.inlineCallbacks
     def terminate_instances(self, context, instance_id, **kwargs):
         logging.debug("Going to start terminating instances")
-        network_topic = yield self._get_network_topic(context)
+        network_topic = self._get_network_topic(context)
         for i in instance_id:
             logging.debug("Going to try and terminate %s" % i)
             try:
-- 
cgit 


From f22c693e4cf638ef5278d9db444da2c4a99baae4 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 31 Aug 2010 13:25:31 -0400
Subject: Remove all Twisted defer references from cloud.py

---
 nova/api/ec2/cloud.py | 86 ++++++++++++++++++++++-----------------------------
 1 file changed, 37 insertions(+), 49 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index decd2a2c0..05fbf3861 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -48,11 +48,8 @@ flags.DEFINE_string('cloud_topic', 'cloud', 'the topic clouds listen on')
 
 def _gen_key(user_id, key_name):
     """ Tuck this into AuthManager """
-    try:
-        mgr = manager.AuthManager()
-        private_key, fingerprint = mgr.generate_key_pair(user_id, key_name)
-    except Exception as ex:
-        return {'exception': ex}
+    mgr = manager.AuthManager()
+    private_key, fingerprint = mgr.generate_key_pair(user_id, key_name)
     return {'private_key': private_key, 'fingerprint': fingerprint}
 
 
@@ -213,18 +210,10 @@ class CloudController(object):
 
     @rbac.allow('all')
     def create_key_pair(self, context, key_name, **kwargs):
-        dcall = defer.Deferred()
-        pool = context.handler.application.settings.get('pool')
-        def _complete(kwargs):
-            if 'exception' in kwargs:
-                dcall.errback(kwargs['exception'])
-                return
-            dcall.callback({'keyName': key_name,
-                'keyFingerprint': kwargs['fingerprint'],
-                'keyMaterial': kwargs['private_key']})
-        pool.apply_async(_gen_key, [context.user.id, key_name],
-            callback=_complete)
-        return dcall
+        data = _gen_key(context.user.id, key_name)
+        return {'keyName': key_name,
+            'keyFingerprint': data['fingerprint'],
+            'keyMaterial': data['private_key']}
 
     @rbac.allow('all')
     def delete_key_pair(self, context, key_name, **kwargs):
@@ -268,7 +257,7 @@ class CloudController(object):
             if context.user.is_admin() or volume['project_id'] == context.project.id:
                 v = self.format_volume(context, volume)
                 volumes.append(v)
-        return defer.succeed({'volumeSet': volumes})
+        return {'volumeSet': volumes}
 
     def format_volume(self, context, volume):
         v = {}
@@ -304,7 +293,7 @@ class CloudController(object):
                                            "project_id": context.project.id}})
         # NOTE(vish): rpc returned value is in the result key in the dictionary
         volume = self._get_volume(context, result)
-        defer.returnValue({'volumeSet': [self.format_volume(context, volume)]})
+        return {'volumeSet': [self.format_volume(context, volume)]}
 
     def _get_address(self, context, public_ip):
         # FIXME(vish) this should move into network.py
@@ -352,12 +341,12 @@ class CloudController(object):
                                  "args": {"volume_id": volume_id,
                                            "instance_id": instance_id,
                                            "mountpoint": device}})
-        return defer.succeed({'attachTime': volume['attach_time'],
-                              'device': volume['mountpoint'],
-                              'instanceId': instance_id,
-                              'requestId': context.request_id,
-                              'status': volume['attach_status'],
-                              'volumeId': volume_id})
+        return {'attachTime': volume['attach_time'],
+                'device': volume['mountpoint'],
+                'instanceId': instance_id,
+                'requestId': context.request_id,
+                'status': volume['attach_status'],
+                'volumeId': volume_id}
 
     @rbac.allow('projectmanager', 'sysadmin')
     def detach_volume(self, context, volume_id, **kwargs):
@@ -378,12 +367,12 @@ class CloudController(object):
             # If the instance doesn't exist anymore,
             # then we need to call detach blind
             volume.finish_detach()
-        return defer.succeed({'attachTime': volume['attach_time'],
-                              'device': volume['mountpoint'],
-                              'instanceId': instance_id,
-                              'requestId': context.request_id,
-                              'status': volume['attach_status'],
-                              'volumeId': volume_id})
+        return {'attachTime': volume['attach_time'],
+                'device': volume['mountpoint'],
+                'instanceId': instance_id,
+                'requestId': context.request_id,
+                'status': volume['attach_status'],
+                'volumeId': volume_id})
 
     def _convert_to_set(self, lst, label):
         if lst == None or lst == []:
@@ -394,7 +383,7 @@ class CloudController(object):
 
     @rbac.allow('all')
     def describe_instances(self, context, **kwargs):
-        return defer.succeed(self._format_describe_instances(context))
+        return self._format_describe_instances(context)
 
     def _format_describe_instances(self, context):
         return { 'reservationSet': self._format_instances(context) }
@@ -483,7 +472,7 @@ class CloudController(object):
                          {"method": "allocate_elastic_ip",
                           "args": {"user_id": context.user.id,
                                    "project_id": context.project.id}})
-        defer.returnValue({'addressSet': [{'publicIp': public_ip}]})
+        return {'addressSet': [{'publicIp': public_ip}]}
 
     @rbac.allow('netadmin')
     def release_address(self, context, public_ip, **kwargs):
@@ -492,7 +481,7 @@ class CloudController(object):
         rpc.cast(network_topic,
                          {"method": "deallocate_elastic_ip",
                           "args": {"elastic_ip": public_ip}})
-        defer.returnValue({'releaseResponse': ["Address released."]})
+        return {'releaseResponse': ["Address released."]}
 
     @rbac.allow('netadmin')
     def associate_address(self, context, instance_id, public_ip, **kwargs):
@@ -504,7 +493,7 @@ class CloudController(object):
                           "args": {"elastic_ip": address['address'],
                                    "fixed_ip": instance['private_dns_name'],
                                    "instance_id": instance['instance_id']}})
-        defer.returnValue({'associateResponse': ["Address associated."]})
+        return {'associateResponse': ["Address associated."]}
 
     @rbac.allow('netadmin')
     def disassociate_address(self, context, public_ip, **kwargs):
@@ -513,7 +502,7 @@ class CloudController(object):
         rpc.cast(network_topic,
                          {"method": "disassociate_elastic_ip",
                           "args": {"elastic_ip": address['address']}})
-        defer.returnValue({'disassociateResponse': ["Address disassociated."]})
+        return {'disassociateResponse': ["Address disassociated."]}
 
     def _get_network_topic(self, context):
         """Retrieves the network host for a project"""
@@ -523,7 +512,7 @@ class CloudController(object):
                                     {"method": "set_network_host",
                                      "args": {"user_id": context.user.id,
                                               "project_id": context.project.id}})
-        defer.returnValue('%s.%s' %(FLAGS.network_topic, host))
+        return '%s.%s' %(FLAGS.network_topic, host)
 
     @rbac.allow('projectmanager', 'sysadmin')
     def run_instances(self, context, **kwargs):
@@ -596,7 +585,7 @@ class CloudController(object):
             logging.debug("Casting to node for %s's instance with IP of %s" %
                       (context.user.name, inst['private_dns_name']))
         # TODO: Make Network figure out the network name from ip.
-        defer.returnValue(self._format_run_instances(context, reservation_id))
+        return self._format_run_instances(context, reservation_id)
 
     @rbac.allow('projectmanager', 'sysadmin')
     def terminate_instances(self, context, instance_id, **kwargs):
@@ -637,7 +626,7 @@ class CloudController(object):
                           "args": {"instance_id": i}})
             else:
                 instance.destroy()
-        defer.returnValue(True)
+        return True
 
     @rbac.allow('projectmanager', 'sysadmin')
     def reboot_instances(self, context, instance_id, **kwargs):
@@ -647,7 +636,7 @@ class CloudController(object):
             rpc.cast('%s.%s' % (FLAGS.compute_topic, instance['node_name']),
                              {"method": "reboot_instance",
                               "args": {"instance_id": i}})
-        return defer.succeed(True)
+        return True
 
     @rbac.allow('projectmanager', 'sysadmin')
     def delete_volume(self, context, volume_id, **kwargs):
@@ -657,19 +646,19 @@ class CloudController(object):
         rpc.cast('%s.%s' % (FLAGS.volume_topic, volume_node),
                             {"method": "delete_volume",
                              "args": {"volume_id": volume_id}})
-        return defer.succeed(True)
+        return True
 
     @rbac.allow('all')
     def describe_images(self, context, image_id=None, **kwargs):
         # The objectstore does its own authorization for describe
         imageSet = images.list(context, image_id)
-        return defer.succeed({'imagesSet': imageSet})
+        return {'imagesSet': imageSet}
 
     @rbac.allow('projectmanager', 'sysadmin')
     def deregister_image(self, context, image_id, **kwargs):
         # FIXME: should the objectstore be doing these authorization checks?
         images.deregister(context, image_id)
-        return defer.succeed({'imageId': image_id})
+        return {'imageId': image_id}
 
     @rbac.allow('projectmanager', 'sysadmin')
     def register_image(self, context, image_location=None, **kwargs):
@@ -679,7 +668,7 @@ class CloudController(object):
         image_id = images.register(context, image_location)
         logging.debug("Registered %s as %s" % (image_location, image_id))
 
-        return defer.succeed({'imageId': image_id})
+        return {'imageId': image_id}
 
     @rbac.allow('all')
     def describe_image_attribute(self, context, image_id, attribute, **kwargs):
@@ -692,7 +681,7 @@ class CloudController(object):
         result = {'image_id': image_id, 'launchPermission': []}
         if image['isPublic']:
             result['launchPermission'].append({'group': 'all'})
-        return defer.succeed(result)
+        return result
 
     @rbac.allow('projectmanager', 'sysadmin')
     def modify_image_attribute(self, context, image_id, attribute, operation_type, **kwargs):
@@ -705,15 +694,14 @@ class CloudController(object):
             raise exception.ApiError('only group "all" is supported')
         if not operation_type in ['add', 'remove']:
             raise exception.ApiError('operation_type must be add or remove')
-        result = images.modify(context, image_id, operation_type)
-        return defer.succeed(result)
+        return images.modify(context, image_id, operation_type)
 
     def update_state(self, topic, value):
         """ accepts status reports from the queue and consolidates them """
         # TODO(jmc): if an instance has disappeared from
         # the node, call instance_death
         if topic == "instances":
-            return defer.succeed(True)
+            return True
         aggregate_state = getattr(self, topic)
         node_name = value.keys()[0]
         items = value[node_name]
@@ -726,4 +714,4 @@ class CloudController(object):
                 del aggregate_state['pending'][item_id]
         aggregate_state[node_name] = items
 
-        return defer.succeed(True)
+        return True
-- 
cgit 


From 544b73d35895ac79af910a40590095780f224abb Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 1 Sep 2010 10:50:31 -0400
Subject: Return error Responses properly, and don't muck with req.params --
 make a copy instead

---
 nova/api/ec2/__init__.py | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index b4a1894cc..248a66f55 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -22,6 +22,7 @@ Starting point for routing EC2 requests
 
 import logging
 import routes
+import webob
 import webob.dec
 import webob.exc
 
@@ -46,8 +47,7 @@ class Authenticate(wsgi.Middleware):
 
     @webob.dec.wsgify
     def __call__(self, req):
-        #TODO(gundlach): where do arguments come from?
-        args = self.request.arguments
+        args = dict(req.params)
 
         # Read request signature.
         try:
@@ -92,8 +92,9 @@ class Authenticate(wsgi.Middleware):
             _log.debug('arg: %s\t\tval: %s' % (key, value))
 
         # Authenticated!
-        req.environ['ec2.action'] = action
         req.environ['ec2.context'] = APIRequestContext(user, project)
+        req.environ['ec2.action'] = action
+        req.environ['ec2.action_args'] = args
         return self.application
 
 
@@ -119,24 +120,24 @@ class Router(wsgi.Application):
         try:
             controller = self.controllers[controller_name]
         except KeyError:
-            self._error('unhandled', 'no controller named %s' % controller_name)
-            return
+            return self._error('unhandled', 'no controller named %s' % controller_name)
 
         api_request = APIRequest(controller, req.environ['ec2.action'])
         context = req.environ['ec2.context']
         try:
-            return api_request.send(context, **args)
+            return api_request.send(context, **req.environ['ec2.action_args'])
         except exception.ApiError as ex:
-            self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
+            return self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
         # TODO(vish): do something more useful with unknown exceptions
         except Exception as ex:
-            self._error(type(ex).__name__, str(ex))
+            return self._error(type(ex).__name__, str(ex))
 
     def _error(self, req, code, message):
-        req.status = 400
-        req.headers['Content-Type'] = 'text/xml'
-        req.response = ('<?xml version="1.0"?>\n'
+        resp = webob.Response()
+        resp.status = 400
+        resp.headers['Content-Type'] = 'text/xml'
+        resp.body = ('<?xml version="1.0"?>\n'
                      '<Response><Errors><Error><Code>%s</Code>'
                      '<Message>%s</Message></Error></Errors>'
                      '<RequestID>?</RequestID></Response>') % (code, message))
-
+        return resp
-- 
cgit 


From 8de182446993ac24e7b8fba12342f8adb3e179d4 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 1 Sep 2010 12:02:14 -0400
Subject: Break Router() into Router() and Executor(), and put Authorizer()
 (currently a stub) in between them.

---
 nova/api/ec2/__init__.py | 101 +++++++++++++++++++++++++++++------------------
 1 file changed, 62 insertions(+), 39 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 248a66f55..87a72ca7c 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -40,36 +40,23 @@ class API(wsgi.Middleware):
     """Routing for all EC2 API requests."""
 
     def __init__(self):
-        self.application = Authenticate(Router())
+        self.application = Authenticate(Router(Authorizer(Executor())))
 
 class Authenticate(wsgi.Middleware):
-    """Authenticates an EC2 request."""
+    """Authenticate an EC2 request and add 'ec2.context' to WSGI environ."""
 
     @webob.dec.wsgify
     def __call__(self, req):
-        args = dict(req.params)
-
-        # Read request signature.
+        # Read request signature and access id.
         try:
-            signature = args.pop('Signature')[0]
+            signature = req.params['Signature']
+            access = req.params['AWSAccessKeyId']
         except:
             raise webob.exc.HTTPBadRequest()
 
         # Make a copy of args for authentication and signature verification.
-        auth_params = {}
-        for key, value in args.items():
-            auth_params[key] = value[0]
-
-        # Get requested action and remove authentication args for final request.
-        try:
-            action = args.pop('Action')[0]
-            access = args.pop('AWSAccessKeyId')[0]
-            args.pop('SignatureMethod')
-            args.pop('SignatureVersion')
-            args.pop('Version')
-            args.pop('Timestamp')
-        except:
-            raise webob.exc.HTTPBadRequest()
+        auth_params = dict(req.params)
+        auth_params.pop('Signature') # not part of authentication args
 
         # Authenticate the request.
         try:
@@ -86,22 +73,15 @@ class Authenticate(wsgi.Middleware):
             logging.debug("Authentication Failure: %s" % ex)
             raise webob.exc.HTTPForbidden()
 
-        _log.debug('action: %s' % action)
-
-        for key, value in args.items():
-            _log.debug('arg: %s\t\tval: %s' % (key, value))
-
         # Authenticated!
         req.environ['ec2.context'] = APIRequestContext(user, project)
-        req.environ['ec2.action'] = action
-        req.environ['ec2.action_args'] = args
+
         return self.application
 
 
 class Router(wsgi.Application):
     """
-    Finds controller for a request, executes environ['ec2.action'] upon it, and
-    returns an XML response.  If the action fails, returns a 400.
+    Add 'ec2.controller', 'ec2.action', and 'ec2.action_args' to WSGI environ.
     """
     def __init__(self):
         self.map = routes.Mapper()
@@ -111,21 +91,63 @@ class Router(wsgi.Application):
 
     @webob.dec.wsgify
     def __call__(self, req):
-        # Obtain the appropriate controller for this request.
-        match = self.map.match(req.path)
-        if not match:
-            raise webob.exc.HTTPNotFound()
-        controller_name = match['controller_name']
-
+        # Obtain the appropriate controller and action for this request.
         try:
+            match = self.map.match(req.path)
+            controller_name = match['controller_name']
             controller = self.controllers[controller_name]
-        except KeyError:
-            return self._error('unhandled', 'no controller named %s' % controller_name)
+        except:
+            raise webob.exc.HTTPNotFound()
+        non_args = ['Action', 'Signature', 'AWSAccessKeyId', 'SignatureMethod',
+                    'SignatureVersion', 'Version', 'Timestamp']
+        args = dict(req.params)
+        try:
+            action = req.params['Action'] # raise KeyError if omitted
+            for non_arg in non_args:
+                args.pop(non_arg) # remove, but raise KeyError if omitted
+        except:
+            raise webob.exc.HTTPBadRequest()
 
-        api_request = APIRequest(controller, req.environ['ec2.action'])
+        _log.debug('action: %s' % action)
+        for key, value in args.items():
+            _log.debug('arg: %s\t\tval: %s' % (key, value))
+
+        # Success!
+        req.environ['ec2.controller'] = controller
+        req.environ['ec2.action'] = action
+        req.environ['ec2.action_args'] = args
+
+        return self.application
+
+
+class Authorization(wsgi.Middleware):
+    """
+    Verify that ec2.controller and ec2.action in WSGI environ may be executed
+    in ec2.context.
+    """
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        #TODO(gundlach): put rbac information here.
+        return self.application
+    
+
+class Executor(wsg.Application):
+    """
+    Executes 'ec2.action' upon 'ec2.controller', passing 'ec2.context' and 
+    'ec2.action_args' (all variables in WSGI environ.)  Returns an XML
+    response, or a 400 upon failure.
+    """
+    @webob.dec.wsgify
+    def __call__(self, req):
         context = req.environ['ec2.context']
+        controller = req.environ['ec2.controller']
+        action = req.environ['ec2.action']
+        args = req.environ['ec2.action_args']
+
+        api_request = APIRequest(controller, action)
         try:
-            return api_request.send(context, **req.environ['ec2.action_args'])
+            return api_request.send(context, **args)
         except exception.ApiError as ex:
             return self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
         # TODO(vish): do something more useful with unknown exceptions
@@ -141,3 +163,4 @@ class Router(wsgi.Application):
                      '<Message>%s</Message></Error></Errors>'
                      '<RequestID>?</RequestID></Response>') % (code, message))
         return resp
+
-- 
cgit 


From 83df968cfb050bdb6bac981dfcc2d0b1c3dd80db Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 1 Sep 2010 12:42:06 -0400
Subject: Delete rbac.py, moving @rbac decorator knowledge into
 api.ec2.Authorizer WSGI middleware.

---
 nova/api/ec2/__init__.py | 64 +++++++++++++++++++++++++++++++++++++++++++++---
 nova/api/ec2/admin.py    | 31 -----------------------
 nova/api/ec2/cloud.py    | 30 -----------------------
 3 files changed, 60 insertions(+), 65 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 87a72ca7c..aee9915d0 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -122,14 +122,70 @@ class Router(wsgi.Application):
 
 class Authorization(wsgi.Middleware):
     """
-    Verify that ec2.controller and ec2.action in WSGI environ may be executed
-    in ec2.context.
+    Return a 401 if ec2.controller and ec2.action in WSGI environ may not be
+    executed in ec2.context.
     """
 
+    def __init__(self, application):
+        super(Authorization, self).__init__(application)
+        self.action_roles = {
+            'CloudController': {
+                'DescribeAvailabilityzones': ['all'],
+                'DescribeRegions': ['all'],
+                'DescribeSnapshots': ['all'],
+                'DescribeKeyPairs': ['all'],
+                'CreateKeyPair': ['all'],
+                'DeleteKeyPair': ['all'],
+                'DescribeSecurityGroups': ['all'],
+                'CreateSecurityGroup': ['netadmin'],
+                'DeleteSecurityGroup': ['netadmin'],
+                'GetConsoleOutput': ['projectmanager', 'sysadmin'],
+                'DescribeVolumes': ['projectmanager', 'sysadmin'],
+                'CreateVolume': ['projectmanager', 'sysadmin'],
+                'AttachVolume': ['projectmanager', 'sysadmin'],
+                'DetachVolume': ['projectmanager', 'sysadmin'],
+                'DescribeInstances': ['all'],
+                'DescribeAddresses': ['all'],
+                'AllocateAddress': ['netadmin'],
+                'ReleaseAddress': ['netadmin'],
+                'AssociateAddress': ['netadmin'],
+                'DisassociateAddress': ['netadmin'],
+                'RunInstances': ['projectmanager', 'sysadmin'],
+                'TerminateInstances': ['projectmanager', 'sysadmin'],
+                'RebootInstances': ['projectmanager', 'sysadmin'],
+                'DeleteVolume': ['projectmanager', 'sysadmin'],
+                'DescribeImages': ['all'],
+                'DeregisterImage': ['projectmanager', 'sysadmin'],
+                'RegisterImage': ['projectmanager', 'sysadmin'],
+                'DescribeImageAttribute': ['all'],
+                'ModifyImageAttribute': ['projectmanager', 'sysadmin'],
+            },
+            'AdminController': {
+                # All actions have the same permission: [] (the default)
+                # admins will be allowed to run them
+                # all others will get HTTPUnauthorized.
+            },
+        }
+
     @webob.dec.wsgify
     def __call__(self, req):
-        #TODO(gundlach): put rbac information here.
-        return self.application
+        context = req.environ['ec2.context']
+        controller_name = req.environ['ec2.controller'].__name__
+        action = req.environ['ec2.action']
+        allowed_roles = self.action_roles[controller_name].get(action, [])
+        if self._matches_any_role(context, allowed_roles):
+            return self.application
+        else:
+            raise webob.exc.HTTPUnauthorized()
+
+    def _matches_any_role(self, context, roles):
+        """Return True if any role in roles is allowed in context."""
+        if 'all' in roles:
+            return True
+        if 'none' in roles:
+            return False
+        return any(context.project.has_role(context.user.id, role) 
+                   for role in roles)
     
 
 class Executor(wsg.Application):
diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index d6f622755..f0c643bbd 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -57,46 +57,27 @@ def host_dict(host):
         return {}
 
 
-def admin_only(target):
-    """Decorator for admin-only API calls"""
-    def wrapper(*args, **kwargs):
-        """Internal wrapper method for admin-only API calls"""
-        context = args[1]
-        if context.user.is_admin():
-            return target(*args, **kwargs)
-        else:
-            return {}
-
-    return wrapper
-
-
 class AdminController(object):
     """
     API Controller for users, hosts, nodes, and workers.
-    Trivial admin_only wrapper will be replaced with RBAC,
-    allowing project managers to administer project users.
     """
 
     def __str__(self):
         return 'AdminController'
 
-    @admin_only
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
         return user_dict(manager.AuthManager().get_user(name))
 
-    @admin_only
     def describe_users(self, _context, **_kwargs):
         """Returns all users - should be changed to deal with a list."""
         return {'userSet':
             [user_dict(u) for u in manager.AuthManager().get_users()] }
 
-    @admin_only
     def register_user(self, _context, name, **_kwargs):
         """Creates a new user, and returns generated credentials."""
         return user_dict(manager.AuthManager().create_user(name))
 
-    @admin_only
     def deregister_user(self, _context, name, **_kwargs):
         """Deletes a single user (NOT undoable.)
            Should throw an exception if the user has instances,
@@ -106,13 +87,11 @@ class AdminController(object):
 
         return True
 
-    @admin_only
     def describe_roles(self, context, project_roles=True, **kwargs):
         """Returns a list of allowed roles."""
         roles = manager.AuthManager().get_roles(project_roles)
         return { 'roles': [{'role': r} for r in roles]}
 
-    @admin_only
     def describe_user_roles(self, context, user, project=None, **kwargs):
         """Returns a list of roles for the given user.
            Omitting project will return any global roles that the user has.
@@ -121,7 +100,6 @@ class AdminController(object):
         roles = manager.AuthManager().get_user_roles(user, project=project)
         return { 'roles': [{'role': r} for r in roles]}
 
-    @admin_only
     def modify_user_role(self, context, user, role, project=None,
                          operation='add', **kwargs):
         """Add or remove a role for a user and project."""
@@ -134,7 +112,6 @@ class AdminController(object):
 
         return True
 
-    @admin_only
     def generate_x509_for_user(self, _context, name, project=None, **kwargs):
         """Generates and returns an x509 certificate for a single user.
            Is usually called from a client that will wrap this with
@@ -146,19 +123,16 @@ class AdminController(object):
         user = manager.AuthManager().get_user(name)
         return user_dict(user, base64.b64encode(project.get_credentials(user)))
 
-    @admin_only
     def describe_project(self, context, name, **kwargs):
         """Returns project data, including member ids."""
         return project_dict(manager.AuthManager().get_project(name))
 
-    @admin_only
     def describe_projects(self, context, user=None, **kwargs):
         """Returns all projects - should be changed to deal with a list."""
         return {'projectSet':
             [project_dict(u) for u in
             manager.AuthManager().get_projects(user=user)]}
 
-    @admin_only
     def register_project(self, context, name, manager_user, description=None,
                          member_users=None, **kwargs):
         """Creates a new project"""
@@ -169,20 +143,17 @@ class AdminController(object):
                 description=None,
                 member_users=None))
 
-    @admin_only
     def deregister_project(self, context, name):
         """Permanently deletes a project."""
         manager.AuthManager().delete_project(name)
         return True
 
-    @admin_only
     def describe_project_members(self, context, name, **kwargs):
         project = manager.AuthManager().get_project(name)
         result = {
             'members': [{'member': m} for m in project.member_ids]}
         return result
         
-    @admin_only
     def modify_project_member(self, context, user, project, operation, **kwargs):
         """Add or remove a user from a project."""
         if operation =='add':
@@ -193,7 +164,6 @@ class AdminController(object):
             raise exception.ApiError('operation must be add or remove')
         return True
 
-    @admin_only
     def describe_hosts(self, _context, **_kwargs):
         """Returns status info for all nodes. Includes:
             * Disk Space
@@ -205,7 +175,6 @@ class AdminController(object):
         """
         return {'hostSet': [host_dict(h) for h in model.Host.all()]}
 
-    @admin_only
     def describe_host(self, _context, name, **_kwargs):
         """Returns status info for single node."""
         return host_dict(model.Host.lookup(name))
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 05fbf3861..566887c1a 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -32,7 +32,6 @@ from nova import exception
 from nova import flags
 from nova import rpc
 from nova import utils
-from nova.auth import rbac
 from nova.auth import manager
 from nova.compute import model
 from nova.compute.instance_types import INSTANCE_TYPES
@@ -163,18 +162,15 @@ class CloudController(object):
             data['product-codes'] = i['product_codes']
         return data
 
-    @rbac.allow('all')
     def describe_availability_zones(self, context, **kwargs):
         return {'availabilityZoneInfo': [{'zoneName': 'nova',
                                           'zoneState': 'available'}]}
 
-    @rbac.allow('all')
     def describe_regions(self, context, region_name=None, **kwargs):
         # TODO(vish): region_name is an array.  Support filtering
         return {'regionInfo': [{'regionName': 'nova',
                                 'regionUrl': FLAGS.ec2_url}]}
 
-    @rbac.allow('all')
     def describe_snapshots(self,
                            context,
                            snapshot_id=None,
@@ -190,7 +186,6 @@ class CloudController(object):
                                  'volumeSize': 0,
                                  'description': 'fixme'}]}
 
-    @rbac.allow('all')
     def describe_key_pairs(self, context, key_name=None, **kwargs):
         key_pairs = context.user.get_key_pairs()
         if not key_name is None:
@@ -208,35 +203,29 @@ class CloudController(object):
 
         return {'keypairsSet': result}
 
-    @rbac.allow('all')
     def create_key_pair(self, context, key_name, **kwargs):
         data = _gen_key(context.user.id, key_name)
         return {'keyName': key_name,
             'keyFingerprint': data['fingerprint'],
             'keyMaterial': data['private_key']}
 
-    @rbac.allow('all')
     def delete_key_pair(self, context, key_name, **kwargs):
         context.user.delete_key_pair(key_name)
         # aws returns true even if the key doens't exist
         return True
 
-    @rbac.allow('all')
     def describe_security_groups(self, context, group_names, **kwargs):
         groups = {'securityGroupSet': []}
 
         # Stubbed for now to unblock other things.
         return groups
 
-    @rbac.allow('netadmin')
     def create_security_group(self, context, group_name, **kwargs):
         return True
 
-    @rbac.allow('netadmin')
     def delete_security_group(self, context, group_name, **kwargs):
         return True
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def get_console_output(self, context, instance_id, **kwargs):
         # instance_id is passed in as a list of instances
         instance = self._get_instance(context, instance_id[0])
@@ -250,7 +239,6 @@ class CloudController(object):
         else:
             return None
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def describe_volumes(self, context, **kwargs):
         volumes = []
         for volume in self.volumes:
@@ -284,7 +272,6 @@ class CloudController(object):
             v['attachmentSet'] = [{}]
         return v
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def create_volume(self, context, size, **kwargs):
         # TODO(vish): refactor this to create the volume object here and tell service to create it
         result = rpc.call(FLAGS.volume_topic, {"method": "create_volume",
@@ -324,7 +311,6 @@ class CloudController(object):
             return volume
         raise exception.NotFound('Volume %s could not be found' % volume_id)
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
         volume = self._get_volume(context, volume_id)
         if volume['status'] == "attached":
@@ -348,7 +334,6 @@ class CloudController(object):
                 'status': volume['attach_status'],
                 'volumeId': volume_id}
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def detach_volume(self, context, volume_id, **kwargs):
         volume = self._get_volume(context, volume_id)
         instance_id = volume.get('instance_id', None)
@@ -381,7 +366,6 @@ class CloudController(object):
             lst = [lst]
         return [{label: x} for x in lst]
 
-    @rbac.allow('all')
     def describe_instances(self, context, **kwargs):
         return self._format_describe_instances(context)
 
@@ -442,7 +426,6 @@ class CloudController(object):
 
         return list(reservations.values())
 
-    @rbac.allow('all')
     def describe_addresses(self, context, **kwargs):
         return self.format_addresses(context)
 
@@ -465,7 +448,6 @@ class CloudController(object):
             addresses.append(address_rv)
         return {'addressesSet': addresses}
 
-    @rbac.allow('netadmin')
     def allocate_address(self, context, **kwargs):
         network_topic = self._get_network_topic(context)
         public_ip = rpc.call(network_topic,
@@ -474,7 +456,6 @@ class CloudController(object):
                                    "project_id": context.project.id}})
         return {'addressSet': [{'publicIp': public_ip}]}
 
-    @rbac.allow('netadmin')
     def release_address(self, context, public_ip, **kwargs):
         # NOTE(vish): Should we make sure this works?
         network_topic = self._get_network_topic(context)
@@ -483,7 +464,6 @@ class CloudController(object):
                           "args": {"elastic_ip": public_ip}})
         return {'releaseResponse': ["Address released."]}
 
-    @rbac.allow('netadmin')
     def associate_address(self, context, instance_id, public_ip, **kwargs):
         instance = self._get_instance(context, instance_id)
         address = self._get_address(context, public_ip)
@@ -495,7 +475,6 @@ class CloudController(object):
                                    "instance_id": instance['instance_id']}})
         return {'associateResponse': ["Address associated."]}
 
-    @rbac.allow('netadmin')
     def disassociate_address(self, context, public_ip, **kwargs):
         address = self._get_address(context, public_ip)
         network_topic = self._get_network_topic(context)
@@ -514,7 +493,6 @@ class CloudController(object):
                                               "project_id": context.project.id}})
         return '%s.%s' %(FLAGS.network_topic, host)
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def run_instances(self, context, **kwargs):
         # make sure user can access the image
         # vpn image is private so it doesn't show up on lists
@@ -587,7 +565,6 @@ class CloudController(object):
         # TODO: Make Network figure out the network name from ip.
         return self._format_run_instances(context, reservation_id)
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def terminate_instances(self, context, instance_id, **kwargs):
         logging.debug("Going to start terminating instances")
         network_topic = self._get_network_topic(context)
@@ -628,7 +605,6 @@ class CloudController(object):
                 instance.destroy()
         return True
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def reboot_instances(self, context, instance_id, **kwargs):
         """instance_id is a list of instance ids"""
         for i in instance_id:
@@ -638,7 +614,6 @@ class CloudController(object):
                               "args": {"instance_id": i}})
         return True
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def delete_volume(self, context, volume_id, **kwargs):
         # TODO: return error if not authorized
         volume = self._get_volume(context, volume_id)
@@ -648,19 +623,16 @@ class CloudController(object):
                              "args": {"volume_id": volume_id}})
         return True
 
-    @rbac.allow('all')
     def describe_images(self, context, image_id=None, **kwargs):
         # The objectstore does its own authorization for describe
         imageSet = images.list(context, image_id)
         return {'imagesSet': imageSet}
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def deregister_image(self, context, image_id, **kwargs):
         # FIXME: should the objectstore be doing these authorization checks?
         images.deregister(context, image_id)
         return {'imageId': image_id}
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def register_image(self, context, image_location=None, **kwargs):
         # FIXME: should the objectstore be doing these authorization checks?
         if image_location is None and kwargs.has_key('name'):
@@ -670,7 +642,6 @@ class CloudController(object):
 
         return {'imageId': image_id}
 
-    @rbac.allow('all')
     def describe_image_attribute(self, context, image_id, attribute, **kwargs):
         if attribute != 'launchPermission':
             raise exception.ApiError('attribute not supported: %s' % attribute)
@@ -683,7 +654,6 @@ class CloudController(object):
             result['launchPermission'].append({'group': 'all'})
         return result
 
-    @rbac.allow('projectmanager', 'sysadmin')
     def modify_image_attribute(self, context, image_id, attribute, operation_type, **kwargs):
         # TODO(devcamcar): Support users and groups other than 'all'.
         if attribute != 'launchPermission':
-- 
cgit 


From b965dde9e95e16a9a207697d5729bd146c2dfd23 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 1 Sep 2010 13:55:38 -0400
Subject: Fix simple errors to the point where we can run the tests [but not
 pass]

---
 nova/api/ec2/__init__.py          | 10 ++++++----
 nova/api/ec2/apirequestcontext.py | 33 ---------------------------------
 nova/api/ec2/cloud.py             |  2 +-
 nova/api/ec2/context.py           | 33 +++++++++++++++++++++++++++++++++
 4 files changed, 40 insertions(+), 38 deletions(-)
 delete mode 100644 nova/api/ec2/apirequestcontext.py
 create mode 100644 nova/api/ec2/context.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index aee9915d0..3335338e0 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -26,9 +26,11 @@ import webob
 import webob.dec
 import webob.exc
 
+from nova import exception
+from nova import wsgi
+from nova.api.ec2 import context
 from nova.api.ec2 import admin
 from nova.api.ec2 import cloud
-from nova import exception
 from nova.auth import manager
 
 
@@ -74,7 +76,7 @@ class Authenticate(wsgi.Middleware):
             raise webob.exc.HTTPForbidden()
 
         # Authenticated!
-        req.environ['ec2.context'] = APIRequestContext(user, project)
+        req.environ['ec2.context'] = context.APIRequestContext(user, project)
 
         return self.application
 
@@ -188,7 +190,7 @@ class Authorization(wsgi.Middleware):
                    for role in roles)
     
 
-class Executor(wsg.Application):
+class Executor(wsgi.Application):
     """
     Executes 'ec2.action' upon 'ec2.controller', passing 'ec2.context' and 
     'ec2.action_args' (all variables in WSGI environ.)  Returns an XML
@@ -217,6 +219,6 @@ class Executor(wsg.Application):
         resp.body = ('<?xml version="1.0"?>\n'
                      '<Response><Errors><Error><Code>%s</Code>'
                      '<Message>%s</Message></Error></Errors>'
-                     '<RequestID>?</RequestID></Response>') % (code, message))
+                     '<RequestID>?</RequestID></Response>') % (code, message)
         return resp
 
diff --git a/nova/api/ec2/apirequestcontext.py b/nova/api/ec2/apirequestcontext.py
deleted file mode 100644
index fb3118020..000000000
--- a/nova/api/ec2/apirequestcontext.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-APIRequestContext
-"""
-
-import random
-
-class APIRequestContext(object):
-    def __init__(self, handler, user, project):
-        self.handler = handler
-        self.user = user
-        self.project = project
-        self.request_id = ''.join(
-                [random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-')
-                 for x in xrange(20)]
-                )
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 566887c1a..fc0eb2711 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -357,7 +357,7 @@ class CloudController(object):
                 'instanceId': instance_id,
                 'requestId': context.request_id,
                 'status': volume['attach_status'],
-                'volumeId': volume_id})
+                'volumeId': volume_id}
 
     def _convert_to_set(self, lst, label):
         if lst == None or lst == []:
diff --git a/nova/api/ec2/context.py b/nova/api/ec2/context.py
new file mode 100644
index 000000000..fb3118020
--- /dev/null
+++ b/nova/api/ec2/context.py
@@ -0,0 +1,33 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequestContext
+"""
+
+import random
+
+class APIRequestContext(object):
+    def __init__(self, handler, user, project):
+        self.handler = handler
+        self.user = user
+        self.project = project
+        self.request_id = ''.join(
+                [random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-')
+                 for x in xrange(20)]
+                )
-- 
cgit 


From 8169a2a26c5b646a4d6c63c77f15f6aaa6898cb4 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 2 Sep 2010 13:04:05 -0400
Subject: Small typos, plus rework api_unittest to use WSGI instead of Tornado

---
 nova/api/__init__.py     |  2 +-
 nova/api/ec2/__init__.py | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 0166b7fc1..786b246ec 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -37,5 +37,5 @@ class API(wsgi.Router):
         # be dropped; and I'm leaving off CloudPipeRequestHandler until
         # I hear that we need it.
         mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API())
-        mapper.connect("/ec2/{path_info:.*}", controller=ec2.API())
+        mapper.connect("/services/{path_info:.*}", controller=ec2.API())
         super(API, self).__init__(mapper)
diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 3335338e0..a94bcb863 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -44,6 +44,7 @@ class API(wsgi.Middleware):
     def __init__(self):
         self.application = Authenticate(Router(Authorizer(Executor())))
 
+
 class Authenticate(wsgi.Middleware):
     """Authenticate an EC2 request and add 'ec2.context' to WSGI environ."""
 
@@ -81,11 +82,12 @@ class Authenticate(wsgi.Middleware):
         return self.application
 
 
-class Router(wsgi.Application):
+class Router(wsgi.Middleware):
     """
     Add 'ec2.controller', 'ec2.action', and 'ec2.action_args' to WSGI environ.
     """
-    def __init__(self):
+    def __init__(self, application):
+        super(Router, self).__init__(application)
         self.map = routes.Mapper()
         self.map.connect("/{controller_name}/")
         self.controllers = dict(Cloud=cloud.CloudController(),
@@ -122,14 +124,14 @@ class Router(wsgi.Application):
         return self.application
 
 
-class Authorization(wsgi.Middleware):
+class Authorizer(wsgi.Middleware):
     """
     Return a 401 if ec2.controller and ec2.action in WSGI environ may not be
     executed in ec2.context.
     """
 
     def __init__(self, application):
-        super(Authorization, self).__init__(application)
+        super(Authorizer, self).__init__(application)
         self.action_roles = {
             'CloudController': {
                 'DescribeAvailabilityzones': ['all'],
-- 
cgit 


From 0fa141a231107da931c396f113b00329d63ee430 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 2 Sep 2010 15:10:55 -0400
Subject: Remove unused APIRequestContext.handler

---
 nova/api/ec2/context.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/context.py b/nova/api/ec2/context.py
index fb3118020..f69747622 100644
--- a/nova/api/ec2/context.py
+++ b/nova/api/ec2/context.py
@@ -23,8 +23,7 @@ APIRequestContext
 import random
 
 class APIRequestContext(object):
-    def __init__(self, handler, user, project):
-        self.handler = handler
+    def __init__(self, user, project):
         self.user = user
         self.project = project
         self.request_id = ''.join(
-- 
cgit 


From b360aded9cfeebfd7594b1b649bd2a1573203cd3 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 2 Sep 2010 15:43:55 -0400
Subject: send requests to the main API instead of to the EC2 subset -- so that
 it can parse out the '/services/' prefix.  Also, oops, match on path_info
 instead of path like we're supposed to.

---
 nova/api/ec2/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index a94bcb863..1722617ae 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -97,7 +97,7 @@ class Router(wsgi.Middleware):
     def __call__(self, req):
         # Obtain the appropriate controller and action for this request.
         try:
-            match = self.map.match(req.path)
+            match = self.map.match(req.path_info)
             controller_name = match['controller_name']
             controller = self.controllers[controller_name]
         except:
-- 
cgit 


From 3075cc7440a37118d7784057874887f751e1f6a3 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 2 Sep 2010 15:53:57 -0400
Subject: OMG got api_unittests to pass

---
 nova/api/ec2/__init__.py   | 11 +++++++----
 nova/api/ec2/apirequest.py |  6 +++++-
 2 files changed, 12 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 1722617ae..e53e7d964 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -28,6 +28,7 @@ import webob.exc
 
 from nova import exception
 from nova import wsgi
+from nova.api.ec2 import apirequest
 from nova.api.ec2 import context
 from nova.api.ec2 import admin
 from nova.api.ec2 import cloud
@@ -174,7 +175,7 @@ class Authorizer(wsgi.Middleware):
     @webob.dec.wsgify
     def __call__(self, req):
         context = req.environ['ec2.context']
-        controller_name = req.environ['ec2.controller'].__name__
+        controller_name = req.environ['ec2.controller'].__class__.__name__
         action = req.environ['ec2.action']
         allowed_roles = self.action_roles[controller_name].get(action, [])
         if self._matches_any_role(context, allowed_roles):
@@ -205,14 +206,16 @@ class Executor(wsgi.Application):
         action = req.environ['ec2.action']
         args = req.environ['ec2.action_args']
 
-        api_request = APIRequest(controller, action)
+        api_request = apirequest.APIRequest(controller, action)
         try:
-            return api_request.send(context, **args)
+            result = api_request.send(context, **args)
+            req.headers['Content-Type'] = 'text/xml'
+            return result
         except exception.ApiError as ex:
             return self._error(req, type(ex).__name__ + "." + ex.code, ex.message)
         # TODO(vish): do something more useful with unknown exceptions
         except Exception as ex:
-            return self._error(type(ex).__name__, str(ex))
+            return self._error(req, type(ex).__name__, str(ex))
 
     def _error(self, req, code, message):
         resp = webob.Response()
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index 261346a09..85ff2fa5e 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -20,9 +20,14 @@
 APIRequest class
 """
 
+import logging
+import re
 # TODO(termie): replace minidom with etree
 from xml.dom import minidom
 
+_log = logging.getLogger("api")
+_log.setLevel(logging.DEBUG)
+
 
 _c2u = re.compile('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
 
@@ -79,7 +84,6 @@ class APIRequest(object):
 
         result = method(context, **args)
 
-        req.headers['Content-Type'] = 'text/xml'
         return self._render_response(result, context.request_id)
 
     def _render_response(self, response_data, request_id):
-- 
cgit 


From 59adf260b59dcdcc6bc2df3260a331a4a05f535c Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 2 Sep 2010 15:59:52 -0400
Subject: Move nova.endpoint.images to api.ec2 and delete nova.endpoint

---
 nova/api/ec2/cloud.py  |  2 +-
 nova/api/ec2/images.py | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 81 insertions(+), 1 deletion(-)
 create mode 100644 nova/api/ec2/images.py

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index e3122bbfc..5c9e1b170 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -35,7 +35,7 @@ from nova import utils
 from nova.auth import manager
 from nova.compute import model
 from nova.compute.instance_types import INSTANCE_TYPES
-from nova.endpoint import images
+from nova.api.ec2 import images
 from nova.network import service as network_service
 from nova.network import model as network_model
 from nova.volume import service
diff --git a/nova/api/ec2/images.py b/nova/api/ec2/images.py
new file mode 100644
index 000000000..cfea4c20b
--- /dev/null
+++ b/nova/api/ec2/images.py
@@ -0,0 +1,80 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Proxy AMI-related calls from the cloud controller, to the running
+objectstore daemon.
+"""
+
+import json
+import urllib
+
+import boto.s3.connection
+
+from nova import image
+from nova import flags
+from nova import utils
+from nova.auth import manager
+
+
+FLAGS = flags.FLAGS
+
+
+def modify(context, image_id, operation):
+    image.S3ImageService(context)._conn().make_request(
+        method='POST',
+        bucket='_images',
+        query_args=qs({'image_id': image_id, 'operation': operation}))
+
+    return True
+
+
+def register(context, image_location):
+    """ rpc call to register a new image based from a manifest """
+
+    image_id = utils.generate_uid('ami')
+    image.S3ImageService(context)._conn().make_request(
+            method='PUT',
+            bucket='_images',
+            query_args=qs({'image_location': image_location,
+                           'image_id': image_id}))
+
+    return image_id
+
+
+def list(context, filter_list=[]):
+    """ return a list of all images that a user can see
+
+    optionally filtered by a list of image_id """
+
+    result = image.S3ImageService(context).index().values()
+    if not filter_list is None:
+        return [i for i in result if i['imageId'] in filter_list]
+    return result
+
+
+def deregister(context, image_id):
+    """ unregister an image """
+    image.S3ImageService(context).delete(image_id)
+
+
+def qs(params):
+    pairs = []
+    for key in params.keys():
+        pairs.append(key + '=' + urllib.quote(params[key]))
+    return '&'.join(pairs)
-- 
cgit 


From e3c7f34bbcc09cbb169d9316c50da6d908ac623c Mon Sep 17 00:00:00 2001
From: Matt Dietz <matt.dietz@rackspace.com>
Date: Thu, 2 Sep 2010 15:34:33 -0500
Subject: Servers API remodeling and serialization handling

---
 nova/api/rackspace/base.py    |  8 +---
 nova/api/rackspace/servers.py | 89 ++++++++++++++++++++++++++++++-------------
 2 files changed, 64 insertions(+), 33 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/base.py b/nova/api/rackspace/base.py
index dd2c6543c..5e5bd6f54 100644
--- a/nova/api/rackspace/base.py
+++ b/nova/api/rackspace/base.py
@@ -21,10 +21,4 @@ from nova import wsgi
 class Controller(wsgi.Controller):
     """TODO(eday): Base controller for all rackspace controllers. What is this
     for? Is this just Rackspace specific? """
-
-    @classmethod
-    def render(cls, instance):
-        if isinstance(instance, list):
-            return {cls.entity_name: cls.render(instance)}
-        else:
-            return {"TODO": "TODO"}
+    pass
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 25d1fe9c8..940b7061f 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -18,56 +18,76 @@
 from nova import rpc
 from nova.compute import model as compute
 from nova.api.rackspace import base
+from webob import exc
+from nova import flags
+
+FLAGS = flags.FLAGS
 
 
 class Controller(base.Controller):
-    entity_name = 'servers'
 
-    def index(self, **kwargs):
-        instances = []
-        for inst in compute.InstanceDirectory().all:
-            instances.append(instance_details(inst))
+    _serialization_metadata = {
+        'application/xml': {
+            "plurals": "servers",
+            "attributes": {
+                "server": [ "id", "imageId", "flavorId", "hostId", "status",
+                           "progress", "addresses", "metadata", "progress" ]
+            }
+        }
+    }
+
+    def __init__(self):
+        self.instdir = compute.InstanceDirectory()
+
+    def index(self, req):
+        return [_entity_inst(instance_details(inst)) for inst in instdir.all]
 
-    def show(self, **kwargs):
-        instance_id = kwargs['id']
-        return compute.InstanceDirectory().get(instance_id)
+    def show(self, req, id):
+        inst = self.instdir.get(id)
+        if inst:
+            return _entity_inst(inst)
+        raise exc.HTTPNotFound()
 
-    def delete(self, **kwargs):
-        instance_id = kwargs['id']
-        instance = compute.InstanceDirectory().get(instance_id)
+    def delete(self, req, id):
+        instance = self.instdir.get(id)
         if not instance:
-            raise ServerNotFound("The requested server was not found")
+            return exc.HTTPNotFound()
         instance.destroy()
-        return True
+        return exc.HTTPAccepted()
 
-    def create(self, **kwargs):
-        inst = self.build_server_instance(kwargs['server'])
+    def create(self, req):
+        inst = self._build_server_instance(req)
         rpc.cast(
             FLAGS.compute_topic, {
                 "method": "run_instance",
                 "args": {"instance_id": inst.instance_id}})
+        return _entity_inst(inst)
 
-    def update(self, **kwargs):
-        instance_id = kwargs['id']
-        instance = compute.InstanceDirectory().get(instance_id)
+    def update(self, req, id):
+        instance = self.instdir.get(instance_id)
         if not instance:
-            raise ServerNotFound("The requested server was not found")
+            return exc.HTTPNotFound()
         instance.update(kwargs['server'])
         instance.save()
+        return exc.HTTPNoContent()
 
-    def build_server_instance(self, env):
+    def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
-        reservation = utils.generate_uid('r')
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
         inst = self.instdir.new()
         inst['name'] = env['server']['name']
         inst['image_id'] = env['server']['imageId']
         inst['instance_type'] = env['server']['flavorId']
         inst['user_id'] = env['user']['id']
-        inst['project_id'] = env['project']['id']
-        inst['reservation_id'] = reservation
+
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
+
+        # TODO(dietz) Do we need any of these?
+        inst['project_id'] = env['project']['id']
+        inst['reservation_id'] = reservation
+        reservation = utils.generate_uid('r')
+
         address = self.network.allocate_ip(
                     inst['user_id'],
                     inst['project_id'],
@@ -77,7 +97,24 @@ class Controller(base.Controller):
                                 inst['user_id'],
                                 inst['project_id'],
                                 'default')['bridge_name']
-        # key_data, key_name, ami_launch_index
-        # TODO(todd): key data or root password
+
         inst.save()
-        return inst
+        return _entity_inst(inst)
+
+    def _entity_inst(self, inst):
+        """ Maps everything to Rackspace-like attributes for return"""
+
+        translated_keys = dict(metadata={}, status=state_description,
+            id=instance_id, imageId=image_id, flavorId=instance_type,)
+
+        for k,v in translated_keys.iteritems():
+            inst[k] = inst[v]
+
+        filtered_keys = ['instance_id', 'state_description', 'state',
+            'reservation_id', 'project_id', 'launch_time',
+            'bridge_name', 'mac_address', 'user_id']
+
+        for key in filtered_keys::
+            del inst[key]
+
+        return dict(server=inst)
-- 
cgit 


From b080169f94e9b3785a73da38a81a0ce302fcff37 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Thu, 2 Sep 2010 23:04:41 -0700
Subject: removed references to compute.model

---
 nova/api/rackspace/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 25d1fe9c8..603a18944 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -16,9 +16,9 @@
 #    under the License.
 
 from nova import rpc
-from nova.compute import model as compute
 from nova.api.rackspace import base
 
+# FIXME(vish): convert from old usage of instance directory
 
 class Controller(base.Controller):
     entity_name = 'servers'
-- 
cgit 


From c32beae895df87b8bac9fc4fed6bf73c19924b19 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Tue, 7 Sep 2010 20:03:07 -0700
Subject: first pass at cleanup rackspace/servers.py

---
 nova/api/rackspace/servers.py | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 603a18944..44174ca52 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -14,27 +14,31 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+import time
 
+from nova import db
+from nova import flags
 from nova import rpc
+from nova import utils
 from nova.api.rackspace import base
 
-# FIXME(vish): convert from old usage of instance directory
+FLAGS = flags.FLAGS
 
 class Controller(base.Controller):
     entity_name = 'servers'
 
     def index(self, **kwargs):
         instances = []
-        for inst in compute.InstanceDirectory().all:
+        for inst in db.instance_get_all(None):
             instances.append(instance_details(inst))
 
     def show(self, **kwargs):
         instance_id = kwargs['id']
-        return compute.InstanceDirectory().get(instance_id)
+        return db.instance_get(None, instance_id)
 
     def delete(self, **kwargs):
         instance_id = kwargs['id']
-        instance = compute.InstanceDirectory().get(instance_id)
+        instance = db.instance_get(None, instance_id)
         if not instance:
             raise ServerNotFound("The requested server was not found")
         instance.destroy()
@@ -45,11 +49,11 @@ class Controller(base.Controller):
         rpc.cast(
             FLAGS.compute_topic, {
                 "method": "run_instance",
-                "args": {"instance_id": inst.instance_id}})
+                "args": {"instance_id": inst['id']}})
 
     def update(self, **kwargs):
         instance_id = kwargs['id']
-        instance = compute.InstanceDirectory().get(instance_id)
+        instance = db.instance_get(None, instance_id)
         if not instance:
             raise ServerNotFound("The requested server was not found")
         instance.update(kwargs['server'])
@@ -59,7 +63,7 @@ class Controller(base.Controller):
         """Build instance data structure and save it to the data store."""
         reservation = utils.generate_uid('r')
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
-        inst = self.instdir.new()
+        inst = {}
         inst['name'] = env['server']['name']
         inst['image_id'] = env['server']['imageId']
         inst['instance_type'] = env['server']['flavorId']
@@ -68,15 +72,8 @@ class Controller(base.Controller):
         inst['reservation_id'] = reservation
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
-        address = self.network.allocate_ip(
-                    inst['user_id'],
-                    inst['project_id'],
-                    mac=inst['mac_address'])
-        inst['private_dns_name'] = str(address)
-        inst['bridge_name'] = network.BridgedNetwork.get_network_for_project(
-                                inst['user_id'],
-                                inst['project_id'],
-                                'default')['bridge_name']
+        inst_id = db.instance_create(None, inst)
+        address = self.network_manager.allocate_fixed_ip(None, inst_id)
         # key_data, key_name, ami_launch_index
         # TODO(todd): key data or root password
         inst.save()
-- 
cgit 


From 345749f514291928913a1ecb280b92daec2c0553 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 9 Sep 2010 19:23:27 -0400
Subject: Correct style issues brought up in termie's review

---
 nova/api/ec2/__init__.py   | 37 +++++++++++++++++++------------------
 nova/api/ec2/apirequest.py |  2 --
 nova/api/ec2/cloud.py      | 15 +++++++--------
 nova/api/ec2/context.py    |  1 +
 nova/api/ec2/images.py     | 21 +++++++--------------
 5 files changed, 34 insertions(+), 42 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index e53e7d964..d500b127c 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -16,9 +16,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Starting point for routing EC2 requests
-"""
+"""Starting point for routing EC2 requests"""
 
 import logging
 import routes
@@ -40,6 +38,7 @@ _log.setLevel(logging.DEBUG)
 
 
 class API(wsgi.Middleware):
+
     """Routing for all EC2 API requests."""
 
     def __init__(self):
@@ -47,6 +46,7 @@ class API(wsgi.Middleware):
 
 
 class Authenticate(wsgi.Middleware):
+
     """Authenticate an EC2 request and add 'ec2.context' to WSGI environ."""
 
     @webob.dec.wsgify
@@ -65,28 +65,25 @@ class Authenticate(wsgi.Middleware):
         # Authenticate the request.
         try:
             (user, project) = manager.AuthManager().authenticate(
-                access,
-                signature,
-                auth_params,
-                req.method,
-                req.host,
-                req.path
-            )
-
+                    access,
+                    signature,
+                    auth_params,
+                    req.method,
+                    req.host,
+                    req.path)
         except exception.Error, ex:
             logging.debug("Authentication Failure: %s" % ex)
             raise webob.exc.HTTPForbidden()
 
         # Authenticated!
         req.environ['ec2.context'] = context.APIRequestContext(user, project)
-
         return self.application
 
 
 class Router(wsgi.Middleware):
-    """
-    Add 'ec2.controller', 'ec2.action', and 'ec2.action_args' to WSGI environ.
-    """
+
+    """Add ec2.'controller', .'action', and .'action_args' to WSGI environ."""
+
     def __init__(self, application):
         super(Router, self).__init__(application)
         self.map = routes.Mapper()
@@ -121,12 +118,13 @@ class Router(wsgi.Middleware):
         req.environ['ec2.controller'] = controller
         req.environ['ec2.action'] = action
         req.environ['ec2.action_args'] = args
-
         return self.application
 
 
 class Authorizer(wsgi.Middleware):
-    """
+
+    """Authorize an EC2 API request.
+
     Return a 401 if ec2.controller and ec2.action in WSGI environ may not be
     executed in ec2.context.
     """
@@ -194,11 +192,14 @@ class Authorizer(wsgi.Middleware):
     
 
 class Executor(wsgi.Application):
-    """
+
+    """Execute an EC2 API request.
+
     Executes 'ec2.action' upon 'ec2.controller', passing 'ec2.context' and 
     'ec2.action_args' (all variables in WSGI environ.)  Returns an XML
     response, or a 400 upon failure.
     """
+
     @webob.dec.wsgify
     def __call__(self, req):
         context = req.environ['ec2.context']
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index 85ff2fa5e..a3b20118f 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -51,7 +51,6 @@ class APIRequest(object):
         self.action = action
 
     def send(self, context, **kwargs):
-
         try:
             method = getattr(self.controller,
                              _camelcase_to_underscore(self.action))
@@ -83,7 +82,6 @@ class APIRequest(object):
                     args[key] = [v for k, v in s]
 
         result = method(context, **args)
-
         return self._render_response(result, context.request_id)
 
     def _render_response(self, response_data, request_id):
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 5c9e1b170..e1e04ca90 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -205,8 +205,8 @@ class CloudController(object):
     def create_key_pair(self, context, key_name, **kwargs):
         data = _gen_key(context.user.id, key_name)
         return {'keyName': key_name,
-            'keyFingerprint': data['fingerprint'],
-            'keyMaterial': data['private_key']}
+                'keyFingerprint': data['fingerprint'],
+                'keyMaterial': data['private_key']}
 
     def delete_key_pair(self, context, key_name, **kwargs):
         context.user.delete_key_pair(key_name)
@@ -273,10 +273,11 @@ class CloudController(object):
 
     def create_volume(self, context, size, **kwargs):
         # TODO(vish): refactor this to create the volume object here and tell service to create it
-        result = rpc.call(FLAGS.volume_topic, {"method": "create_volume",
-                                 "args": {"size": size,
-                                           "user_id": context.user.id,
-                                           "project_id": context.project.id}})
+        result = rpc.call(FLAGS.volume_topic, 
+                {"method": "create_volume",
+                 "args": {"size": size,
+                          "user_id": context.user.id,
+                          "project_id": context.project.id}})
         # NOTE(vish): rpc returned value is in the result key in the dictionary
         volume = self._get_volume(context, result)
         return {'volumeSet': [self.format_volume(context, volume)]}
@@ -638,7 +639,6 @@ class CloudController(object):
             image_location = kwargs['name']
         image_id = images.register(context, image_location)
         logging.debug("Registered %s as %s" % (image_location, image_id))
-
         return {'imageId': image_id}
 
     def describe_image_attribute(self, context, image_id, attribute, **kwargs):
@@ -682,5 +682,4 @@ class CloudController(object):
                 aggregate_state['pending'].has_key(item_id)):
                 del aggregate_state['pending'][item_id]
         aggregate_state[node_name] = items
-
         return True
diff --git a/nova/api/ec2/context.py b/nova/api/ec2/context.py
index f69747622..c53ba98d9 100644
--- a/nova/api/ec2/context.py
+++ b/nova/api/ec2/context.py
@@ -22,6 +22,7 @@ APIRequestContext
 
 import random
 
+
 class APIRequestContext(object):
     def __init__(self, user, project):
         self.user = user
diff --git a/nova/api/ec2/images.py b/nova/api/ec2/images.py
index cfea4c20b..f0be7b899 100644
--- a/nova/api/ec2/images.py
+++ b/nova/api/ec2/images.py
@@ -26,20 +26,20 @@ import urllib
 
 import boto.s3.connection
 
-from nova import image
 from nova import flags
 from nova import utils
 from nova.auth import manager
+from nova.image import service
 
 
 FLAGS = flags.FLAGS
 
 
 def modify(context, image_id, operation):
-    image.S3ImageService(context)._conn().make_request(
+    service.S3ImageService(context)._conn().make_request(
         method='POST',
         bucket='_images',
-        query_args=qs({'image_id': image_id, 'operation': operation}))
+        query_args=service.qs({'image_id': image_id, 'operation': operation}))
 
     return True
 
@@ -48,10 +48,10 @@ def register(context, image_location):
     """ rpc call to register a new image based from a manifest """
 
     image_id = utils.generate_uid('ami')
-    image.S3ImageService(context)._conn().make_request(
+    service.S3ImageService(context)._conn().make_request(
             method='PUT',
             bucket='_images',
-            query_args=qs({'image_location': image_location,
+            query_args=service.qs({'image_location': image_location,
                            'image_id': image_id}))
 
     return image_id
@@ -62,7 +62,7 @@ def list(context, filter_list=[]):
 
     optionally filtered by a list of image_id """
 
-    result = image.S3ImageService(context).index().values()
+    result = service.S3ImageService(context).index().values()
     if not filter_list is None:
         return [i for i in result if i['imageId'] in filter_list]
     return result
@@ -70,11 +70,4 @@ def list(context, filter_list=[]):
 
 def deregister(context, image_id):
     """ unregister an image """
-    image.S3ImageService(context).delete(image_id)
-
-
-def qs(params):
-    pairs = []
-    for key in params.keys():
-        pairs.append(key + '=' + urllib.quote(params[key]))
-    return '&'.join(pairs)
+    service.S3ImageService(context).delete(image_id)
-- 
cgit 


From 6f5c16b62c441c97ade4f2f4b4878e8015c9281e Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Thu, 9 Sep 2010 21:52:06 -0700
Subject: make the db creates return refs instead of ids

---
 nova/api/rackspace/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 44174ca52..1815f7523 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -72,7 +72,7 @@ class Controller(base.Controller):
         inst['reservation_id'] = reservation
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
-        inst_id = db.instance_create(None, inst)
+        inst_id = db.instance_create(None, inst)['id']
         address = self.network_manager.allocate_fixed_ip(None, inst_id)
         # key_data, key_name, ami_launch_index
         # TODO(todd): key data or root password
-- 
cgit 


From 5e02ee47c0e86986bb21f67a4d6556895de5d0ef Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 13 Sep 2010 11:53:53 -0400
Subject: Pull S3ImageService out of this mergeprop

---
 nova/api/ec2/images.py | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/images.py b/nova/api/ec2/images.py
index f0be7b899..b5ce2b2cc 100644
--- a/nova/api/ec2/images.py
+++ b/nova/api/ec2/images.py
@@ -29,17 +29,16 @@ import boto.s3.connection
 from nova import flags
 from nova import utils
 from nova.auth import manager
-from nova.image import service
 
 
 FLAGS = flags.FLAGS
 
 
 def modify(context, image_id, operation):
-    service.S3ImageService(context)._conn().make_request(
+    conn(context).make_request(
         method='POST',
         bucket='_images',
-        query_args=service.qs({'image_id': image_id, 'operation': operation}))
+        query_args=qs({'image_id': image_id, 'operation': operation}))
 
     return True
 
@@ -48,10 +47,10 @@ def register(context, image_location):
     """ rpc call to register a new image based from a manifest """
 
     image_id = utils.generate_uid('ami')
-    service.S3ImageService(context)._conn().make_request(
+    conn(context).make_request(
             method='PUT',
             bucket='_images',
-            query_args=service.qs({'image_location': image_location,
+            query_args=qs({'image_location': image_location,
                            'image_id': image_id}))
 
     return image_id
@@ -62,7 +61,12 @@ def list(context, filter_list=[]):
 
     optionally filtered by a list of image_id """
 
-    result = service.S3ImageService(context).index().values()
+    # FIXME: send along the list of only_images to check for
+    response = conn(context).make_request(
+            method='GET',
+            bucket='_images')
+
+    result = json.loads(response.read())
     if not filter_list is None:
         return [i for i in result if i['imageId'] in filter_list]
     return result
@@ -70,4 +74,20 @@ def list(context, filter_list=[]):
 
 def deregister(context, image_id):
     """ unregister an image """
-    service.S3ImageService(context).delete(image_id)
+    conn(context).make_request(
+            method='DELETE',
+            bucket='_images',
+            query_args=qs({'image_id': image_id}))
+
+
+def conn(context):
+    access = manager.AuthManager().get_access_key(context.user,
+                                                  context.project)
+    secret = str(context.user.secret)
+    calling = boto.s3.connection.OrdinaryCallingFormat()
+    return boto.s3.connection.S3Connection(aws_access_key_id=access,
+                                           aws_secret_access_key=secret,
+                                           is_secure=False,
+                                           calling_format=calling,
+                                           port=FLAGS.s3_port,
+                                           host=FLAGS.s3_host)
-- 
cgit 


From 2b87ea1ab445a5a9fb089acb0220189f736d420a Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 13 Sep 2010 12:02:50 -0400
Subject: Finish pulling S3ImageService out of this mergeprop

---
 nova/api/ec2/images.py | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/ec2/images.py b/nova/api/ec2/images.py
index b5ce2b2cc..2a88d66af 100644
--- a/nova/api/ec2/images.py
+++ b/nova/api/ec2/images.py
@@ -91,3 +91,10 @@ def conn(context):
                                            calling_format=calling,
                                            port=FLAGS.s3_port,
                                            host=FLAGS.s3_host)
+
+
+def qs(params):
+    pairs = []
+    for key in params.keys():
+        pairs.append(key + '=' + urllib.quote(params[key]))
+    return '&'.join(pairs)
-- 
cgit 


From 3d68f1f74cd7fe6ddb9eec003a9e31f8ad036b27 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 14 Sep 2010 16:26:19 -0400
Subject: Add ratelimiting package into Nova.  After Austin it'll be pulled out
 into PyPI.

---
 nova/api/rackspace/ratelimiting/__init__.py | 103 ++++++++++++++++++++++++++++
 nova/api/rackspace/ratelimiting/tests.py    |  60 ++++++++++++++++
 2 files changed, 163 insertions(+)
 create mode 100644 nova/api/rackspace/ratelimiting/__init__.py
 create mode 100644 nova/api/rackspace/ratelimiting/tests.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/ratelimiting/__init__.py b/nova/api/rackspace/ratelimiting/__init__.py
new file mode 100644
index 000000000..176e7d66e
--- /dev/null
+++ b/nova/api/rackspace/ratelimiting/__init__.py
@@ -0,0 +1,103 @@
+"""Rate limiting of arbitrary actions."""
+
+import time
+import urllib
+import webob.dec
+import webob.exc
+
+
+# Convenience constants for the limits dictionary passed to Limiter().
+PER_SECOND = 1
+PER_MINUTE = 60
+PER_HOUR = 60 * 60
+PER_DAY = 60 * 60 * 24
+
+class Limiter(object):
+
+    """Class providing rate limiting of arbitrary actions."""
+
+    def __init__(self, limits):
+        """Create a rate limiter.
+
+        limits: a dict mapping from action name to a tuple.  The tuple contains
+        the number of times the action may be performed, and the time period
+        (in seconds) during which the number must not be exceeded for this
+        action.  Example: dict(reboot=(10, ratelimiting.PER_MINUTE)) would
+        allow 10 'reboot' actions per minute.
+        """
+        self.limits = limits
+        self._levels = {}
+
+    def perform(self, action_name, username='nobody'):
+        """Attempt to perform an action by the given username.
+
+        action_name: the string name of the action to perform.  This must
+        be a key in the limits dict passed to the ctor.
+
+        username: an optional string name of the user performing the action.
+        Each user has her own set of rate limiting counters.  Defaults to
+        'nobody' (so that if you never specify a username when calling
+        perform(), a single set of counters will be used.)
+
+        Return None if the action may proceed.  If the action may not proceed
+        because it has been rate limited, return the float number of seconds
+        until the action would succeed.
+        """
+        # Think of rate limiting as a bucket leaking water at 1cc/second.  The
+        # bucket can hold as many ccs as there are seconds in the rate
+        # limiting period (e.g. 3600 for per-hour ratelimits), and if you can
+        # perform N actions in that time, each action fills the bucket by
+        # 1/Nth of its volume.  You may only perform an action if the bucket
+        # would not overflow.
+        now = time.time()
+        key = '%s:%s' % (username, action_name)
+        last_time_performed, water_level = self._levels.get(key, (now, 0))
+        # The bucket leaks 1cc/second.
+        water_level -= (now - last_time_performed)
+        if water_level < 0:
+            water_level = 0
+        num_allowed_per_period, period_in_secs = self.limits[action_name]
+        # Fill the bucket by 1/Nth its capacity, and hope it doesn't overflow.
+        capacity = period_in_secs
+        new_level = water_level + (capacity * 1.0 / num_allowed_per_period)
+        if new_level > capacity:
+            # Delay this many seconds.
+            return new_level - capacity
+        self._levels[key] = (now, new_level)
+        return None
+
+
+# If one instance of this WSGIApps is unable to handle your load, put a
+# sharding app in front that shards by username to one of many backends.
+
+class WSGIApp(object):
+
+    """Application that tracks rate limits in memory.  Send requests to it of
+    this form:
+
+    POST /limiter/<username>/<urlencoded action>
+
+    and receive a 200 OK, or a 403 Forbidden with an X-Wait-Seconds header
+    containing the number of seconds to wait before the action would succeed.
+    """
+
+    def __init__(self, limiter):
+        """Create the WSGI application using the given Limiter instance."""
+        self.limiter = limiter
+
+    @webob.dec.wsgify
+    def __call__(req):
+        parts = req.path_info.split('/')
+        # format: /limiter/<username>/<urlencoded action>
+        if req.method != 'POST':
+            raise webob.exc.HTTPMethodNotAllowed()
+        if len(parts) != 4 or parts[1] != 'limiter':
+            raise webob.exc.HTTPNotFound()
+        username = parts[2]
+        action_name = urllib.unquote(parts[3])
+        delay = self.limiter.perform(action_name, username)
+        if delay:
+            return webob.exc.HTTPForbidden(
+                    headers={'X-Wait-Seconds': delay})
+        else:
+            return '' # 200 OK
diff --git a/nova/api/rackspace/ratelimiting/tests.py b/nova/api/rackspace/ratelimiting/tests.py
new file mode 100644
index 000000000..1983cdea8
--- /dev/null
+++ b/nova/api/rackspace/ratelimiting/tests.py
@@ -0,0 +1,60 @@
+import ratelimiting
+import time
+import unittest
+
+class Test(unittest.TestCase):
+
+    def setUp(self):
+        self.limits = {
+                'a': (5, ratelimiting.PER_SECOND),
+                'b': (5, ratelimiting.PER_MINUTE),
+                'c': (5, ratelimiting.PER_HOUR),
+                'd': (1, ratelimiting.PER_SECOND),
+                'e': (100, ratelimiting.PER_SECOND)}
+        self.rl = ratelimiting.Limiter(self.limits)
+
+    def exhaust(self, action, times_until_exhausted, **kwargs):
+        for i in range(times_until_exhausted):
+            when = self.rl.perform(action, **kwargs)
+            self.assertEqual(when, None)
+        num, period = self.limits[action]
+        delay = period * 1.0 / num
+        # Verify that we are now thoroughly delayed
+        for i in range(10):
+            when = self.rl.perform(action, **kwargs)
+            self.assertAlmostEqual(when, delay, 2)
+
+    def test_second(self):
+        self.exhaust('a', 5)
+        time.sleep(0.2)
+        self.exhaust('a', 1)
+        time.sleep(1)
+        self.exhaust('a', 5)
+
+    def test_minute(self):
+        self.exhaust('b', 5)
+
+    def test_one_per_period(self):
+        def allow_once_and_deny_once():
+            when = self.rl.perform('d')
+            self.assertEqual(when, None)
+            when = self.rl.perform('d')
+            self.assertAlmostEqual(when, 1, 2)
+            return when
+        time.sleep(allow_once_and_deny_once())
+        time.sleep(allow_once_and_deny_once())
+        allow_once_and_deny_once()
+
+    def test_we_can_go_indefinitely_if_we_spread_out_requests(self):
+        for i in range(200):
+            when = self.rl.perform('e')
+            self.assertEqual(when, None)
+            time.sleep(0.01)
+
+    def test_users_get_separate_buckets(self):
+        self.exhaust('c', 5, username='alice')
+        self.exhaust('c', 5, username='bob')
+        self.exhaust('c', 5, username='chuck')
+        self.exhaust('c', 0, username='chuck')
+        self.exhaust('c', 0, username='bob')
+        self.exhaust('c', 0, username='alice')
-- 
cgit 


From 8138a35d3672e08640762b7533c1c527568d0b4f Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 14 Sep 2010 18:59:02 -0400
Subject: RateLimitingMiddleware

---
 nova/api/rackspace/__init__.py | 52 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index b4d666d63..e35109b43 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -31,6 +31,7 @@ from nova import flags
 from nova import wsgi
 from nova.api.rackspace import flavors
 from nova.api.rackspace import images
+from nova.api.rackspace import ratelimiting
 from nova.api.rackspace import servers
 from nova.api.rackspace import sharedipgroups
 from nova.auth import manager
@@ -40,7 +41,7 @@ class API(wsgi.Middleware):
     """WSGI entry point for all Rackspace API requests."""
 
     def __init__(self):
-        app = AuthMiddleware(APIRouter())
+        app = AuthMiddleware(RateLimitingMiddleware(APIRouter()))
         super(API, self).__init__(app)
 
 
@@ -65,6 +66,55 @@ class AuthMiddleware(wsgi.Middleware):
         return self.application
 
 
+class RateLimitingMiddleware(wsgi.Middleware):
+    """Rate limit incoming requests according to the OpenStack rate limits."""
+
+    def __init__(self, application):
+        super(RateLimitingMiddleware, self).__init__(application)
+        #TODO(gundlach): These limits were based on limitations of Cloud 
+        #Servers.  We should revisit them in Nova.
+        self.limiter = ratelimiting.Limiter(limits={
+                'DELETE': (100, ratelimiting.PER_MINUTE),
+                'PUT': (10, ratelimiting.PER_MINUTE),
+                'POST': (10, ratelimiting.PER_MINUTE),
+                'POST servers': (50, ratelimiting.PER_DAY),
+                'GET changes-since': (3, ratelimiting.PER_MINUTE),
+            })
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        """Rate limit the request.
+        
+        If the request should be rate limited, return a 413 status with a 
+        Retry-After header giving the time when the request would succeed.
+        """
+        username = req.headers['X-Auth-User']
+        action_name = self.get_action_name(req)
+        if not action_name: # not rate limited
+            return self.application
+        delay = self.limiter.perform(action_name, username=username)
+        if action_name == 'POST servers':
+            # "POST servers" is a POST, so it counts against "POST" too.
+            delay2 = self.limiter.perform('POST', username=username)
+            delay = max(delay or 0, delay2 or 0)
+        if delay:
+            # TODO(gundlach): Get the retry-after format correct.
+            raise webob.exc.HTTPRequestEntityTooLarge(headers={
+                    'Retry-After': time.time() + delay})
+        else:
+            return self.application
+
+    def get_action_name(self, req):
+        """Return the action name for this request."""
+        if req.method == 'GET' and 'changes-since' in req.GET:
+            return 'GET changes-since'
+        if req.method == 'POST' and req.path_info.starts_with('/servers'):
+            return 'POST servers'
+        if req.method in ['PUT', 'POST', 'DELETE']:
+            return req.method
+        return None
+
+
 class APIRouter(wsgi.Router):
     """
     Routes requests on the Rackspace API to the appropriate controller
-- 
cgit 


From 63ad073efd0b20f59f02bc37182c0180cac3f405 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 15 Sep 2010 09:25:53 -0400
Subject: RateLimitingMiddleware tests

---
 nova/api/rackspace/__init__.py           | 24 ++++++++++++++++--------
 nova/api/rackspace/ratelimiting/tests.py |  3 +++
 2 files changed, 19 insertions(+), 8 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index e35109b43..66d80a5b7 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -92,23 +92,31 @@ class RateLimitingMiddleware(wsgi.Middleware):
         action_name = self.get_action_name(req)
         if not action_name: # not rate limited
             return self.application
-        delay = self.limiter.perform(action_name, username=username)
-        if action_name == 'POST servers':
-            # "POST servers" is a POST, so it counts against "POST" too.
-            delay2 = self.limiter.perform('POST', username=username)
-            delay = max(delay or 0, delay2 or 0)
+        delay = self.get_delay(action_name, username)
         if delay:
             # TODO(gundlach): Get the retry-after format correct.
             raise webob.exc.HTTPRequestEntityTooLarge(headers={
                     'Retry-After': time.time() + delay})
-        else:
-            return self.application
+        return self.application
+
+    def get_delay(self, action_name, username):
+        """Return the delay for the given action and username, or None if
+        the action would not be rate limited.
+        """
+        if action_name == 'POST servers':
+            # "POST servers" is a POST, so it counts against "POST" too.
+            # Attempt the "POST" first, lest we are rate limited by "POST" but
+            # use up a precious "POST servers" call.
+            delay = self.limiter.perform("POST", username=username)
+            if delay:
+                return delay
+        return self.limiter.perform(action_name, username=username)
 
     def get_action_name(self, req):
         """Return the action name for this request."""
         if req.method == 'GET' and 'changes-since' in req.GET:
             return 'GET changes-since'
-        if req.method == 'POST' and req.path_info.starts_with('/servers'):
+        if req.method == 'POST' and req.path_info.startswith('/servers'):
             return 'POST servers'
         if req.method in ['PUT', 'POST', 'DELETE']:
             return req.method
diff --git a/nova/api/rackspace/ratelimiting/tests.py b/nova/api/rackspace/ratelimiting/tests.py
index 1983cdea8..545e1d1b6 100644
--- a/nova/api/rackspace/ratelimiting/tests.py
+++ b/nova/api/rackspace/ratelimiting/tests.py
@@ -58,3 +58,6 @@ class Test(unittest.TestCase):
         self.exhaust('c', 0, username='chuck')
         self.exhaust('c', 0, username='bob')
         self.exhaust('c', 0, username='alice')
+
+if __name__ == '__main__':
+    unittest.main()
-- 
cgit 


From fd4d5787d5b6f6e550d33c13eb76f4562a87a118 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 15 Sep 2010 11:23:08 -0400
Subject: Test the WSGIApp

---
 nova/api/rackspace/ratelimiting/__init__.py |  2 +-
 nova/api/rackspace/ratelimiting/tests.py    | 69 ++++++++++++++++++++++++++++-
 2 files changed, 68 insertions(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/ratelimiting/__init__.py b/nova/api/rackspace/ratelimiting/__init__.py
index 176e7d66e..64d5fff2c 100644
--- a/nova/api/rackspace/ratelimiting/__init__.py
+++ b/nova/api/rackspace/ratelimiting/__init__.py
@@ -86,7 +86,7 @@ class WSGIApp(object):
         self.limiter = limiter
 
     @webob.dec.wsgify
-    def __call__(req):
+    def __call__(self, req):
         parts = req.path_info.split('/')
         # format: /limiter/<username>/<urlencoded action>
         if req.method != 'POST':
diff --git a/nova/api/rackspace/ratelimiting/tests.py b/nova/api/rackspace/ratelimiting/tests.py
index 545e1d1b6..f924e7805 100644
--- a/nova/api/rackspace/ratelimiting/tests.py
+++ b/nova/api/rackspace/ratelimiting/tests.py
@@ -1,8 +1,10 @@
-import ratelimiting
 import time
 import unittest
+import webob
 
-class Test(unittest.TestCase):
+import nova.api.rackspace.ratelimiting as ratelimiting
+
+class LimiterTest(unittest.TestCase):
 
     def setUp(self):
         self.limits = {
@@ -59,5 +61,68 @@ class Test(unittest.TestCase):
         self.exhaust('c', 0, username='bob')
         self.exhaust('c', 0, username='alice')
 
+
+class WSGIAppTest(unittest.TestCase):
+
+    def setUp(self):
+        test = self
+        class FakeLimiter(object):
+            def __init__(self):
+                self._action = self._username = self._delay = None
+            def mock(self, action, username, delay):
+                self._action = action
+                self._username = username
+                self._delay = delay
+            def perform(self, action, username):
+                test.assertEqual(action, self._action)
+                test.assertEqual(username, self._username)
+                return self._delay
+        self.limiter = FakeLimiter()
+        self.app = ratelimiting.WSGIApp(self.limiter)
+
+    def test_invalid_methods(self):
+        requests = []
+        for method in ['GET', 'PUT', 'DELETE']:
+            req = webob.Request.blank('/limits/michael/breakdance', 
+                                      dict(REQUEST_METHOD=method))
+            requests.append(req)
+        for req in requests:
+            self.assertEqual(req.get_response(self.app).status_int, 405)
+
+    def test_invalid_urls(self):
+        requests = []
+        for prefix in ['limit', '', 'limiter2', 'limiter/limits', 'limiter/1']:
+            req = webob.Request.blank('/%s/michael/breakdance' % prefix,
+                                      dict(REQUEST_METHOD='POST'))
+        requests.append(req)
+        for req in requests:
+            self.assertEqual(req.get_response(self.app).status_int, 404)
+
+    def verify(self, url, username, action, delay=None):
+        """Make sure that POSTing to the given url causes the given username
+        to perform the given action.  Make the internal rate limiter return
+        delay and make sure that the WSGI app returns the correct response.
+        """
+        req = webob.Request.blank(url, dict(REQUEST_METHOD='POST'))
+        self.limiter.mock(action, username, delay)
+        resp = req.get_response(self.app)
+        if not delay:
+            self.assertEqual(resp.status_int, 200)
+        else:
+            self.assertEqual(resp.status_int, 403)
+            self.assertEqual(resp.headers['X-Wait-Seconds'], delay)
+
+    def test_good_urls(self):
+        self.verify('/limiter/michael/hoot', 'michael', 'hoot')
+
+    def test_escaping(self):
+        self.verify('/limiter/michael/jump%20up', 'michael', 'jump up')
+
+    def test_response_to_delays(self):
+        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1)
+        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1.56)
+        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1000)
+
+
 if __name__ == '__main__':
     unittest.main()
-- 
cgit 


From f200587ce068482ab94e777154de3ac777269fa0 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 15 Sep 2010 13:54:38 -0400
Subject: Add support for middleware proxying to a ratelimiting.WSGIApp, for
 deployments that use more than one API Server and thus can't store
 ratelimiting counters in memory.

---
 nova/api/rackspace/__init__.py              |  29 ++++--
 nova/api/rackspace/ratelimiting/__init__.py |  21 ++++-
 nova/api/rackspace/ratelimiting/tests.py    | 140 +++++++++++++++++++++++++---
 3 files changed, 165 insertions(+), 25 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index 66d80a5b7..ac5365310 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -69,17 +69,26 @@ class AuthMiddleware(wsgi.Middleware):
 class RateLimitingMiddleware(wsgi.Middleware):
     """Rate limit incoming requests according to the OpenStack rate limits."""
 
-    def __init__(self, application):
+    def __init__(self, application, service_host=None):
+        """Create a rate limiting middleware that wraps the given application.
+
+        By default, rate counters are stored in memory.  If service_host is
+        specified, the middleware instead relies on the ratelimiting.WSGIApp
+        at the given host+port to keep rate counters.
+        """
         super(RateLimitingMiddleware, self).__init__(application)
-        #TODO(gundlach): These limits were based on limitations of Cloud 
-        #Servers.  We should revisit them in Nova.
-        self.limiter = ratelimiting.Limiter(limits={
-                'DELETE': (100, ratelimiting.PER_MINUTE),
-                'PUT': (10, ratelimiting.PER_MINUTE),
-                'POST': (10, ratelimiting.PER_MINUTE),
-                'POST servers': (50, ratelimiting.PER_DAY),
-                'GET changes-since': (3, ratelimiting.PER_MINUTE),
-            })
+        if not service_host:
+            #TODO(gundlach): These limits were based on limitations of Cloud 
+            #Servers.  We should revisit them in Nova.
+            self.limiter = ratelimiting.Limiter(limits={
+                    'DELETE': (100, ratelimiting.PER_MINUTE),
+                    'PUT': (10, ratelimiting.PER_MINUTE),
+                    'POST': (10, ratelimiting.PER_MINUTE),
+                    'POST servers': (50, ratelimiting.PER_DAY),
+                    'GET changes-since': (3, ratelimiting.PER_MINUTE),
+                })
+        else:
+            self.limiter = ratelimiting.WSGIAppProxy(service_host)
 
     @webob.dec.wsgify
     def __call__(self, req):
diff --git a/nova/api/rackspace/ratelimiting/__init__.py b/nova/api/rackspace/ratelimiting/__init__.py
index 64d5fff2c..f843bac0f 100644
--- a/nova/api/rackspace/ratelimiting/__init__.py
+++ b/nova/api/rackspace/ratelimiting/__init__.py
@@ -1,5 +1,6 @@
 """Rate limiting of arbitrary actions."""
 
+import httplib
 import time
 import urllib
 import webob.dec
@@ -98,6 +99,24 @@ class WSGIApp(object):
         delay = self.limiter.perform(action_name, username)
         if delay:
             return webob.exc.HTTPForbidden(
-                    headers={'X-Wait-Seconds': delay})
+                    headers={'X-Wait-Seconds': "%.2f" % delay})
         else:
             return '' # 200 OK
+
+
+class WSGIAppProxy(object):
+
+    """Limiter lookalike that proxies to a ratelimiting.WSGIApp."""
+
+    def __init__(self, service_host):
+        """Creates a proxy pointing to a ratelimiting.WSGIApp at the given 
+        host."""
+        self.service_host = service_host
+
+    def perform(self, action, username='nobody'):
+        conn = httplib.HTTPConnection(self.service_host)
+        conn.request('POST', '/limiter/%s/%s' % (username, action))
+        resp = conn.getresponse()
+        if resp.status == 200:
+            return None # no delay
+        return float(resp.getheader('X-Wait-Seconds'))
diff --git a/nova/api/rackspace/ratelimiting/tests.py b/nova/api/rackspace/ratelimiting/tests.py
index f924e7805..13a47989b 100644
--- a/nova/api/rackspace/ratelimiting/tests.py
+++ b/nova/api/rackspace/ratelimiting/tests.py
@@ -1,3 +1,5 @@
+import httplib
+import StringIO
 import time
 import unittest
 import webob
@@ -62,22 +64,25 @@ class LimiterTest(unittest.TestCase):
         self.exhaust('c', 0, username='alice')
 
 
+class FakeLimiter(object):
+    """Fake Limiter class that you can tell how to behave."""
+    def __init__(self, test):
+        self._action = self._username = self._delay = None
+        self.test = test
+    def mock(self, action, username, delay):
+        self._action = action
+        self._username = username
+        self._delay = delay
+    def perform(self, action, username):
+        self.test.assertEqual(action, self._action)
+        self.test.assertEqual(username, self._username)
+        return self._delay
+
+
 class WSGIAppTest(unittest.TestCase):
 
     def setUp(self):
-        test = self
-        class FakeLimiter(object):
-            def __init__(self):
-                self._action = self._username = self._delay = None
-            def mock(self, action, username, delay):
-                self._action = action
-                self._username = username
-                self._delay = delay
-            def perform(self, action, username):
-                test.assertEqual(action, self._action)
-                test.assertEqual(username, self._username)
-                return self._delay
-        self.limiter = FakeLimiter()
+        self.limiter = FakeLimiter(self)
         self.app = ratelimiting.WSGIApp(self.limiter)
 
     def test_invalid_methods(self):
@@ -110,7 +115,7 @@ class WSGIAppTest(unittest.TestCase):
             self.assertEqual(resp.status_int, 200)
         else:
             self.assertEqual(resp.status_int, 403)
-            self.assertEqual(resp.headers['X-Wait-Seconds'], delay)
+            self.assertEqual(resp.headers['X-Wait-Seconds'], "%.2f" % delay)
 
     def test_good_urls(self):
         self.verify('/limiter/michael/hoot', 'michael', 'hoot')
@@ -124,5 +129,112 @@ class WSGIAppTest(unittest.TestCase):
         self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1000)
 
 
+class FakeHttplibSocket(object):
+    """a fake socket implementation for httplib.HTTPResponse, trivial"""
+
+    def __init__(self, response_string):
+        self._buffer = StringIO.StringIO(response_string)
+
+    def makefile(self, _mode, _other):
+        """Returns the socket's internal buffer"""
+        return self._buffer
+
+
+class FakeHttplibConnection(object):
+    """A fake httplib.HTTPConnection
+
+    Requests made via this connection actually get translated and routed into
+    our WSGI app, we then wait for the response and turn it back into
+    an httplib.HTTPResponse.
+    """
+    def __init__(self, app, host, is_secure=False):
+        self.app = app
+        self.host = host
+
+    def request(self, method, path, data='', headers={}):
+        req = webob.Request.blank(path)
+        req.method = method
+        req.body = data
+        req.headers = headers
+        req.host = self.host
+        # Call the WSGI app, get the HTTP response
+        resp = str(req.get_response(self.app))
+        # For some reason, the response doesn't have "HTTP/1.0 " prepended; I
+        # guess that's a function the web server usually provides.
+        resp = "HTTP/1.0 %s" % resp
+        sock = FakeHttplibSocket(resp)
+        self.http_response = httplib.HTTPResponse(sock)
+        self.http_response.begin()
+
+    def getresponse(self):
+        return self.http_response
+
+
+def wire_HTTPConnection_to_WSGI(host, app):
+    """Monkeypatches HTTPConnection so that if you try to connect to host, you
+    are instead routed straight to the given WSGI app.
+
+    After calling this method, when any code calls
+
+    httplib.HTTPConnection(host)
+
+    the connection object will be a fake.  Its requests will be sent directly
+    to the given WSGI app rather than through a socket.
+    
+    Code connecting to hosts other than host will not be affected.
+
+    This method may be called multiple times to map different hosts to
+    different apps.
+    """
+    class HTTPConnectionDecorator(object):
+        """Wraps the real HTTPConnection class so that when you instantiate
+        the class you might instead get a fake instance."""
+        def __init__(self, wrapped):
+            self.wrapped = wrapped
+        def __call__(self, connection_host, *args, **kwargs):
+            if connection_host == host:
+                return FakeHttplibConnection(app, host)
+            else:
+                return self.wrapped(connection_host, *args, **kwargs)
+    httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
+
+
+class WSGIAppProxyTest(unittest.TestCase):
+
+    def setUp(self):
+        """Our WSGIAppProxy is going to call across an HTTPConnection to a
+        WSGIApp running a limiter.  The proxy will send input, and the proxy
+        should receive that same input, pass it to the limiter who gives a
+        result, and send the expected result back.
+
+        The HTTPConnection isn't real -- it's monkeypatched to point straight
+        at the WSGIApp.  And the limiter isn't real -- it's a fake that
+        behaves the way we tell it to.
+        """
+        self.limiter = FakeLimiter(self)
+        app = ratelimiting.WSGIApp(self.limiter)
+        wire_HTTPConnection_to_WSGI('100.100.100.100:80', app)
+        self.proxy = ratelimiting.WSGIAppProxy('100.100.100.100:80')
+
+    def test_200(self):
+        self.limiter.mock('conquer', 'caesar', None)
+        when = self.proxy.perform('conquer', 'caesar')
+        self.assertEqual(when, None)
+
+    def test_403(self):
+        self.limiter.mock('grumble', 'proletariat', 1.5)
+        when = self.proxy.perform('grumble', 'proletariat')
+        self.assertEqual(when, 1.5)
+
+    def test_failure(self):
+        self.limiter.mock('murder', 'brutus', None)
+        try:
+            when = self.proxy.perform('stab', 'brutus')
+        except AssertionError:
+            pass
+        else:
+            self.fail("I didn't perform the action I expected")
+
+
 if __name__ == '__main__':
     unittest.main()
-- 
cgit 


From 7437df558f3277e21a4c34a5b517a1cae5dd5a74 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 15 Sep 2010 17:17:20 -0400
Subject: Support querying version list

---
 nova/api/__init__.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index b9b9e3988..9f116dada 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -21,6 +21,7 @@ Root WSGI middleware for all API controllers.
 """
 
 import routes
+import webob.dec
 
 from nova import wsgi
 from nova.api import ec2
@@ -32,6 +33,18 @@ class API(wsgi.Router):
 
     def __init__(self):
         mapper = routes.Mapper()
+        mapper.connect("/", controller=self.versions)
         mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API())
         mapper.connect("/ec2/{path_info:.*}", controller=ec2.API())
         super(API, self).__init__(mapper)
+
+    @webob.dec.wsgify
+    def versions(self, req):
+        """Respond to a request for all OpenStack API versions."""
+        response = {
+                "versions": [
+                    dict(status="CURRENT", id="v1.0")]}
+        metadata = {
+            "application/xml": {
+                "attributes": dict(version=["status", "id"])}}
+        return wsgi.Serializer(req.environ, metadata).to_content_type(response)
-- 
cgit 


From 8e304fe0bf69fe5f6bad2fa3d5a71a93cb0612e8 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 16 Sep 2010 12:39:35 -0400
Subject: Fix things not quite merged perfectly -- all tests now pass

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 7a9b5f5cf..c04e722cc 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -556,7 +556,7 @@ class CloudController(object):
                 # NOTE(vish): Right now we don't really care if the ip is
                 #             disassociated.  We may need to worry about
                 #             checking this later.  Perhaps in the scheduler?
-                network_topic = yield self._get_network_topic(context)
+                network_topic = self._get_network_topic(context)
                 rpc.cast(network_topic,
                          {"method": "disassociate_floating_ip",
                           "args": {"context": None,
-- 
cgit 


From 11b934f75ac4359b75f246fd9babfc3363a9a396 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 16 Sep 2010 14:41:51 -0500
Subject: Replaced the existing Rackspace Auth Mechanism with one that mirrors
 the implementation in the design document.

---
 nova/api/rackspace/__init__.py | 52 +++++++++++++++++++++++++++++++++---------
 nova/api/rackspace/auth.py     | 37 ++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+), 11 deletions(-)
 create mode 100644 nova/api/rackspace/auth.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index b4d666d63..dbba97107 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -26,8 +26,10 @@ import time
 import routes
 import webob.dec
 import webob.exc
+import webob
 
 from nova import flags
+from nova import utils
 from nova import wsgi
 from nova.api.rackspace import flavors
 from nova.api.rackspace import images
@@ -36,6 +38,10 @@ from nova.api.rackspace import sharedipgroups
 from nova.auth import manager
 
 
+FLAGS = flags.FLAGS
+flags.DEFINE_string('nova_api_auth', 'nova.api.rackspace.auth.FakeAuth', 
+    'The auth mechanism to use for the Rackspace API implemenation')
+
 class API(wsgi.Middleware):
     """WSGI entry point for all Rackspace API requests."""
 
@@ -47,23 +53,47 @@ class API(wsgi.Middleware):
 class AuthMiddleware(wsgi.Middleware):
     """Authorize the rackspace API request or return an HTTP Forbidden."""
 
-    #TODO(gundlach): isn't this the old Nova API's auth?  Should it be replaced
-    #with correct RS API auth?
+    def __init__(self, application):
+        self.auth_driver = utils.import_class(FLAGS.nova_api_auth)()
+        super(AuthMiddleware, self).__init__(application)
 
     @webob.dec.wsgify
     def __call__(self, req):
-        context = {}
-        if "HTTP_X_AUTH_TOKEN" in req.environ:
-            context['user'] = manager.AuthManager().get_user_from_access_key(
-                              req.environ['HTTP_X_AUTH_TOKEN'])
-            if context['user']:
-                context['project'] = manager.AuthManager().get_project(
-                                     context['user'].name)
-        if "user" not in context:
-            return webob.exc.HTTPForbidden()
+        if not req.headers.has_key("X-Auth-Token"):
+            return self.authenticate(req)
+
+        user = self.auth_driver.authorize_token(req.headers["X-Auth-Token"])
+
+        if not user:
+            return webob.exc.HTTPUnauthorized()
+        context = {'user':user}
         req.environ['nova.context'] = context
         return self.application
 
+    def authenticate(self, req):
+        # Unless the request is explicitly made against /<version>/ don't
+        # honor it
+        path_info = req.environ['wsgiorg.routing_args'][1]['path_info']
+        if path_info:
+            return webob.exc.HTTPUnauthorized()
+
+        if req.headers.has_key("X-Auth-User") and \
+                req.headers.has_key("X-Auth-Key"):
+            username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
+            token, user = self.auth_driver.authorize_user(username, key)
+            if user and token:
+                res = webob.Response()
+                res.headers['X-Auth-Token'] = token
+                res.headers['X-Server-Management-Url'] = \
+                    user['server_management_url']
+                res.headers['X-Storage-Url'] = user['storage_url']
+                res.headers['X-CDN-Management-Url'] = user['cdn_management_url']
+                res.content_type = 'text/plain'
+                res.status = '204'
+                return res
+            else:
+                return webob.exc.HTTPUnauthorized()
+        return webob.exc.HTTPUnauthorized()
 
 class APIRouter(wsgi.Router):
     """
diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
new file mode 100644
index 000000000..d2b5193c3
--- /dev/null
+++ b/nova/api/rackspace/auth.py
@@ -0,0 +1,37 @@
+import json
+from hashlib import sha1
+from nova import datastore
+
+class FakeAuth(object):
+    def __init__(self, store=datastore.Redis.instance):
+        self._store = store()
+        self.auth_hash = 'rs_fake_auth'
+        self._store.hsetnx(self.auth_hash, 'rs_last_id', 0)
+
+    def authorize_token(self, token):
+        user = self._store.hget(self.auth_hash, token) 
+        if user:
+            return json.loads(user)
+        return None
+
+    def authorize_user(self, user, key):
+        token = sha1("%s_%s" % (user, key)).hexdigest()
+        user = self._store.hget(self.auth_hash, token)
+        if not user:
+            return None, None
+        else:
+            return token, json.loads(user)
+
+    def add_user(self, user, key):
+        last_id = self._store.hget(self.auth_hash, 'rs_last_id')
+        token = sha1("%s_%s" % (user, key)).hexdigest()
+        user = {
+            'id':last_id,
+            'cdn_management_url':'cdn_management_url',
+            'storage_url':'storage_url',
+            'server_management_url':'server_management_url'
+        }
+        new_user = self._store.hsetnx(self.auth_hash, token, json.dumps(user))
+        if new_user:
+            self._store.hincrby(self.auth_hash, 'rs_last_id')
+        
-- 
cgit 


From ae760b13c5382f2f4719dde445235c156cc27d18 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 20 Sep 2010 14:49:05 -0400
Subject: Use assertRaises

---
 nova/api/rackspace/ratelimiting/tests.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/ratelimiting/tests.py b/nova/api/rackspace/ratelimiting/tests.py
index 13a47989b..4c9510917 100644
--- a/nova/api/rackspace/ratelimiting/tests.py
+++ b/nova/api/rackspace/ratelimiting/tests.py
@@ -227,13 +227,10 @@ class WSGIAppProxyTest(unittest.TestCase):
         self.assertEqual(when, 1.5)
 
     def test_failure(self):
-        self.limiter.mock('murder', 'brutus', None)
-        try:
-            when = self.proxy.perform('stab', 'brutus')
-        except AssertionError:
-            pass
-        else:
-            self.fail("I didn't perform the action I expected")
+        def shouldRaise():
+            self.limiter.mock('murder', 'brutus', None)
+            self.proxy.perform('stab', 'brutus')
+        self.assertRaises(AssertionError, shouldRaise)
 
 
 if __name__ == '__main__':
-- 
cgit 


From 64dd3000c4a9b88719e86d1090097e35398d3838 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 20 Sep 2010 18:04:57 -0500
Subject: Refactored the auth branch based on review feedback

---
 nova/api/rackspace/__init__.py |  33 ++----------
 nova/api/rackspace/auth.py     | 117 +++++++++++++++++++++++++++++------------
 2 files changed, 88 insertions(+), 62 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index dbba97107..f62ddc1c7 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -39,7 +39,8 @@ from nova.auth import manager
 
 
 FLAGS = flags.FLAGS
-flags.DEFINE_string('nova_api_auth', 'nova.api.rackspace.auth.FakeAuth', 
+flags.DEFINE_string('nova_api_auth',
+    'nova.api.rackspace.auth.BasicApiAuthManager', 
     'The auth mechanism to use for the Rackspace API implemenation')
 
 class API(wsgi.Middleware):
@@ -49,7 +50,6 @@ class API(wsgi.Middleware):
         app = AuthMiddleware(APIRouter())
         super(API, self).__init__(app)
 
-
 class AuthMiddleware(wsgi.Middleware):
     """Authorize the rackspace API request or return an HTTP Forbidden."""
 
@@ -60,41 +60,16 @@ class AuthMiddleware(wsgi.Middleware):
     @webob.dec.wsgify
     def __call__(self, req):
         if not req.headers.has_key("X-Auth-Token"):
-            return self.authenticate(req)
+            return self.auth_driver.authenticate(req)
 
         user = self.auth_driver.authorize_token(req.headers["X-Auth-Token"])
 
         if not user:
             return webob.exc.HTTPUnauthorized()
-        context = {'user':user}
+        context = {'user': user}
         req.environ['nova.context'] = context
         return self.application
 
-    def authenticate(self, req):
-        # Unless the request is explicitly made against /<version>/ don't
-        # honor it
-        path_info = req.environ['wsgiorg.routing_args'][1]['path_info']
-        if path_info:
-            return webob.exc.HTTPUnauthorized()
-
-        if req.headers.has_key("X-Auth-User") and \
-                req.headers.has_key("X-Auth-Key"):
-            username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
-            token, user = self.auth_driver.authorize_user(username, key)
-            if user and token:
-                res = webob.Response()
-                res.headers['X-Auth-Token'] = token
-                res.headers['X-Server-Management-Url'] = \
-                    user['server_management_url']
-                res.headers['X-Storage-Url'] = user['storage_url']
-                res.headers['X-CDN-Management-Url'] = user['cdn_management_url']
-                res.content_type = 'text/plain'
-                res.status = '204'
-                return res
-            else:
-                return webob.exc.HTTPUnauthorized()
-        return webob.exc.HTTPUnauthorized()
-
 class APIRouter(wsgi.Router):
     """
     Routes requests on the Rackspace API to the appropriate controller
diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
index d2b5193c3..b29596880 100644
--- a/nova/api/rackspace/auth.py
+++ b/nova/api/rackspace/auth.py
@@ -1,37 +1,88 @@
+import datetime
 import json
-from hashlib import sha1
-from nova import datastore
-
-class FakeAuth(object):
-    def __init__(self, store=datastore.Redis.instance):
-        self._store = store()
-        self.auth_hash = 'rs_fake_auth'
-        self._store.hsetnx(self.auth_hash, 'rs_last_id', 0)
-
-    def authorize_token(self, token):
-        user = self._store.hget(self.auth_hash, token) 
-        if user:
-            return json.loads(user)
-        return None
+import time
+import webob.exc
+import webob.dec
+import hashlib
+
+from nova import auth
+from nova import manager
+from nova import db
+
+class Context(object):
+    pass
+
+class BasicApiAuthManager(manager.Manager):
+    """ Implements a somewhat rudimentary version of Rackspace Auth"""
+
+    def __init__(self):
+        self.auth = auth.manager.AuthManager()
+        self.context = Context()
+        super(BasicApiAuthManager, self).__init__()
+
+    def authenticate(self, req):
+        # Unless the request is explicitly made against /<version>/ don't
+        # honor it
+        path_info = req.path_info
+        if len(path_info) > 1:
+            return webob.exc.HTTPUnauthorized()
+
+        try:
+            username, key = req.headers['X-Auth-User'], \
+                req.headers['X-Auth-Key']
+        except KeyError:
+            return webob.exc.HTTPUnauthorized()
 
-    def authorize_user(self, user, key):
-        token = sha1("%s_%s" % (user, key)).hexdigest()
-        user = self._store.hget(self.auth_hash, token)
-        if not user:
-            return None, None
+        username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
+        token, user = self._authorize_user(username, key)
+        if user and token:
+            res = webob.Response()
+            res.headers['X-Auth-Token'] = token['token_hash']
+            res.headers['X-Server-Management-Url'] = \
+                token['server_management_url']
+            res.headers['X-Storage-Url'] = token['storage_url']
+            res.headers['X-CDN-Management-Url'] = token['cdn_management_url']
+            res.content_type = 'text/plain'
+            res.status = '204'
+            return res
         else:
-            return token, json.loads(user)
-
-    def add_user(self, user, key):
-        last_id = self._store.hget(self.auth_hash, 'rs_last_id')
-        token = sha1("%s_%s" % (user, key)).hexdigest()
-        user = {
-            'id':last_id,
-            'cdn_management_url':'cdn_management_url',
-            'storage_url':'storage_url',
-            'server_management_url':'server_management_url'
-        }
-        new_user = self._store.hsetnx(self.auth_hash, token, json.dumps(user))
-        if new_user:
-            self._store.hincrby(self.auth_hash, 'rs_last_id')
+            return webob.exc.HTTPUnauthorized()
+
+    def authorize_token(self, token_hash):
+        """ retrieves user information from the datastore given a token
+        
+        If the token has expired, returns None
+        If the token is not found, returns None
+        Otherwise returns the token
+
+        This method will also remove the token if the timestamp is older than
+        2 days ago.
+        """
+        token = self.db.auth_get_token(self.context, token_hash) 
+        if token:
+            delta = datetime.datetime.now() - token['created_at']
+            if delta.days >= 2:
+                self.db.auth_destroy_token(self.context, token)
+            else:
+                user = self.auth.get_user(self.context, token['user_id'])
+                return { 'id':user['id'] }
+        return None
+
+    def _authorize_user(self, username, key):
+        """ Generates a new token and assigns it to a user """
+        user = self.auth.get_user_from_access_key(key)
+        if user and user['name'] == username:
+            token_hash = hashlib.sha1('%s%s%f' % (username, key,
+                time.time())).hexdigest()
+            token = {}
+            token['token_hash'] = token_hash
+            token['cdn_management_url'] = ''
+            token['server_management_url'] = self._get_server_mgmt_url()
+            token['storage_url'] = ''
+            self.db.auth_create_token(self.context, token, user['id'])
+            return token, user
+        return None, None 
+
+    def _get_server_mgmt_url(self):
+        return 'https://%s/v1.0/' % self.host
         
-- 
cgit 


From 0880e49a4e9c9a246e8f4d7cc805d79947de095a Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 21 Sep 2010 10:07:59 -0500
Subject: Some more refactoring and another unit test

---
 nova/api/rackspace/auth.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
index b29596880..1ef90c324 100644
--- a/nova/api/rackspace/auth.py
+++ b/nova/api/rackspace/auth.py
@@ -4,7 +4,7 @@ import time
 import webob.exc
 import webob.dec
 import hashlib
-
+from nova import flags
 from nova import auth
 from nova import manager
 from nova import db
@@ -12,10 +12,16 @@ from nova import db
 class Context(object):
     pass
 
-class BasicApiAuthManager(manager.Manager):
+class BasicApiAuthManager(object):
     """ Implements a somewhat rudimentary version of Rackspace Auth"""
 
     def __init__(self):
+        if not host:
+            host = FLAGS.host
+        self.host = host                                                                                                                                     
+        if not db_driver:
+            db_driver = FLAGS.db_driver                                                                                                                      
+        self.db = utils.import_object(db_driver)
         self.auth = auth.manager.AuthManager()
         self.context = Context()
         super(BasicApiAuthManager, self).__init__()
@@ -64,8 +70,8 @@ class BasicApiAuthManager(manager.Manager):
             if delta.days >= 2:
                 self.db.auth_destroy_token(self.context, token)
             else:
-                user = self.auth.get_user(self.context, token['user_id'])
-                return { 'id':user['id'] }
+                user = self.auth.get_user(token['user_id'])
+                return { 'id':user['uid'] }
         return None
 
     def _authorize_user(self, username, key):
@@ -79,7 +85,8 @@ class BasicApiAuthManager(manager.Manager):
             token['cdn_management_url'] = ''
             token['server_management_url'] = self._get_server_mgmt_url()
             token['storage_url'] = ''
-            self.db.auth_create_token(self.context, token, user['id'])
+            token['user_id'] = user['uid']
+            self.db.auth_create_token(self.context, token)
             return token, user
         return None, None 
 
-- 
cgit 


From 84fbfe09e10b330a5668e99422247801f370d0f9 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 21 Sep 2010 16:57:08 -0400
Subject: Rewrite rbac tests to use Authorizer middleware

---
 nova/api/ec2/__init__.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index a7b10e428..b041787c2 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -25,6 +25,7 @@ import webob.dec
 import webob.exc
 
 from nova import exception
+from nova import flags
 from nova import wsgi
 from nova.api.ec2 import apirequest
 from nova.api.ec2 import context
@@ -33,6 +34,7 @@ from nova.api.ec2 import cloud
 from nova.auth import manager
 
 
+FLAGS = flags.FLAGS
 _log = logging.getLogger("api")
 _log.setLevel(logging.DEBUG)
 
@@ -176,6 +178,7 @@ class Authorizer(wsgi.Middleware):
         controller_name = req.environ['ec2.controller'].__class__.__name__
         action = req.environ['ec2.action']
         allowed_roles = self.action_roles[controller_name].get(action, [])
+        allowed_roles.extend(FLAGS.superuser_roles)
         if self._matches_any_role(context, allowed_roles):
             return self.application
         else:
-- 
cgit 


From d642716db42b229e879f6f4673f166beb8d55faa Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 21 Sep 2010 17:12:53 -0500
Subject: Added server index and detail differentiation

---
 nova/api/rackspace/__init__.py |  3 ++-
 nova/api/rackspace/servers.py  | 18 ++++++++++++++----
 2 files changed, 16 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index ac5365310..5f4020837 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -140,7 +140,8 @@ class APIRouter(wsgi.Router):
 
     def __init__(self):
         mapper = routes.Mapper()
-        mapper.resource("server", "servers", controller=servers.Controller())
+        mapper.resource("server", "servers", controller=servers.Controller()
+                        collection={'detail': 'GET'})
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
         mapper.resource("flavor", "flavors", controller=flavors.Controller(),
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 5f685dbd4..3ba5af8cf 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -31,8 +31,9 @@ class Controller(base.Controller):
         'application/xml': {
             "plurals": "servers",
             "attributes": {
-                "server": [ "id", "imageId", "flavorId", "hostId", "status",
-                           "progress", "addresses", "metadata", "progress" ]
+                "server": [ "id", "imageId", "name", "flavorId", "hostId", 
+                            "status", "progress", "addresses", "metadata", 
+                            "progress" ]
             }
         }
     }
@@ -41,7 +42,11 @@ class Controller(base.Controller):
         self.instdir = compute.InstanceDirectory()
 
     def index(self, req):
-        return [_entity_inst(instance_details(inst)) for inst in instdir.all]
+        allowed_keys = [ 'id', 'name']
+        return [_entity_inst(inst, allowed_keys) for inst in instdir.all]
+
+    def detail(self, req):
+        return [_entity_inst(inst) for inst in instdir.all]
 
     def show(self, req, id):
         inst = self.instdir.get(id)
@@ -103,7 +108,7 @@ class Controller(base.Controller):
         inst.save()
         return _entity_inst(inst)
 
-    def _entity_inst(self, inst):
+    def _entity_inst(self, inst, allowed_keys=None):
         """ Maps everything to Rackspace-like attributes for return"""
 
         translated_keys = dict(metadata={}, status=state_description,
@@ -119,4 +124,9 @@ class Controller(base.Controller):
         for key in filtered_keys::
             del inst[key]
 
+        if allowed_keys:
+            for key in inst.keys():
+                if key not in allowed_keys:
+                    del inst[key]
+
         return dict(server=inst)
-- 
cgit 


From a8c5901faaa98b7f0c06db086a03a0d38a210986 Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Wed, 22 Sep 2010 18:46:55 +0000
Subject: Added a primary_key to AuthToken, fixed some unbound variables, and
 now all unit tests pass

---
 nova/api/rackspace/auth.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
index 1ef90c324..ce5a967eb 100644
--- a/nova/api/rackspace/auth.py
+++ b/nova/api/rackspace/auth.py
@@ -8,6 +8,9 @@ from nova import flags
 from nova import auth
 from nova import manager
 from nova import db
+from nova import utils
+
+FLAGS = flags.FLAGS
 
 class Context(object):
     pass
@@ -15,7 +18,7 @@ class Context(object):
 class BasicApiAuthManager(object):
     """ Implements a somewhat rudimentary version of Rackspace Auth"""
 
-    def __init__(self):
+    def __init__(self, host=None, db_driver=None):
         if not host:
             host = FLAGS.host
         self.host = host                                                                                                                                     
-- 
cgit 


From 6f82d0f84c9474e72ef70c9ff568d68031191e0a Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 22 Sep 2010 17:35:02 -0400
Subject: Soren's patch to fix part of ec2

---
 nova/api/ec2/apirequest.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index a3b20118f..a87c21fb3 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -68,10 +68,8 @@ class APIRequest(object):
             key = _camelcase_to_underscore(parts[0])
             if len(parts) > 1:
                 d = args.get(key, {})
-                d[parts[1]] = value[0]
+                d[parts[1]] = value
                 value = d
-            else:
-                value = value[0]
             args[key] = value
 
         for key in args.keys():
-- 
cgit 


From f188b5a02d34751e89fae60b4d3b1ef144f138d7 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 22 Sep 2010 19:11:04 -0400
Subject: Re-add root and metadata request handlers to EC2 API

---
 nova/api/__init__.py                   | 56 +++++++++++++++++++++++++--
 nova/api/ec2/metadatarequesthandler.py | 71 ++++++++++++++++++++++++++++++++++
 2 files changed, 123 insertions(+), 4 deletions(-)
 create mode 100644 nova/api/ec2/metadatarequesthandler.py

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 821f1deea..a0be05d86 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -23,9 +23,18 @@ Root WSGI middleware for all API controllers.
 import routes
 import webob.dec
 
+from nova import flags
 from nova import wsgi
 from nova.api import ec2
 from nova.api import rackspace
+from nova.api.ec2 import metadatarequesthandler
+
+
+flags.DEFINE_string('rsapi_subdomain', 'rs', 
+                    'subdomain running the RS API')
+flags.DEFINE_string('ec2api_subdomain', 'ec2', 
+                    'subdomain running the EC2 API')
+FLAGS = flags.FLAGS
 
 
 class API(wsgi.Router):
@@ -33,13 +42,33 @@ class API(wsgi.Router):
 
     def __init__(self):
         mapper = routes.Mapper()
-        mapper.connect("/", controller=self.versions)
-        mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API())
-        mapper.connect("/services/{path_info:.*}", controller=ec2.API())
+        mapper.sub_domains = True
+        mapper.connect("/", controller=self.rsapi_versions, 
+                            conditions={'sub_domain': [FLAGS.rsapi_subdomain]})
+        mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API(),
+                            conditions={'sub_domain': [FLAGS.rsapi_subdomain]})
+
+        mapper.connect("/", controller=self.ec2api_versions,
+                            conditions={'sub_domain': [FLAGS.ec2api_subdomain]})
+        mapper.connect("/services/{path_info:.*}", controller=ec2.API(),
+                            conditions={'sub_domain': [FLAGS.ec2api_subdomain]})
+        mrh = metadatarequesthandler.MetadataRequestHandler()
+        for s in ['/latest',
+                  '/2009-04-04',
+                  '/2008-09-01',
+                  '/2008-02-01',
+                  '/2007-12-15',
+                  '/2007-10-10',
+                  '/2007-08-29',
+                  '/2007-03-01',
+                  '/2007-01-19',
+                  '/1.0']:
+            mapper.connect('%s/{path_info:.*}' % s, controller=mrh,
+                           conditions={'subdomain': FLAGS.ec2api_subdomain})
         super(API, self).__init__(mapper)
 
     @webob.dec.wsgify
-    def versions(self, req):
+    def rsapi_versions(self, req):
         """Respond to a request for all OpenStack API versions."""
         response = {
                 "versions": [
@@ -48,3 +77,22 @@ class API(wsgi.Router):
             "application/xml": {
                 "attributes": dict(version=["status", "id"])}}
         return wsgi.Serializer(req.environ, metadata).to_content_type(response)
+
+    @webob.dec.wsgify
+    def ec2api_versions(self, req):
+        """Respond to a request for all EC2 versions."""
+        # available api versions
+        versions = [
+            '1.0',
+            '2007-01-19',
+            '2007-03-01',
+            '2007-08-29',
+            '2007-10-10',
+            '2007-12-15',
+            '2008-02-01',
+            '2008-09-01',
+            '2009-04-04',
+        ]
+        return ''.join('%s\n' % v for v in versions)
+
+
diff --git a/nova/api/ec2/metadatarequesthandler.py b/nova/api/ec2/metadatarequesthandler.py
new file mode 100644
index 000000000..229e5a78d
--- /dev/null
+++ b/nova/api/ec2/metadatarequesthandler.py
@@ -0,0 +1,71 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Metadata request handler."""
+
+import webob.dec
+import webob.exc
+
+from nova.api.ec2 import cloud
+
+
+class MetadataRequestHandler(object):
+
+    """Serve metadata from the EC2 API."""
+
+    def print_data(self, data):
+        if isinstance(data, dict):
+            output = ''
+            for key in data:
+                if key == '_name':
+                    continue
+                output += key
+                if isinstance(data[key], dict):
+                    if '_name' in data[key]:
+                        output += '=' + str(data[key]['_name'])
+                    else:
+                        output += '/'
+                output += '\n'
+            return output[:-1] # cut off last \n
+        elif isinstance(data, list):
+            return '\n'.join(data)
+        else:
+            return str(data)
+
+    def lookup(self, path, data):
+        items = path.split('/')
+        for item in items:
+            if item:
+                if not isinstance(data, dict):
+                    return data
+                if not item in data:
+                    return None
+                data = data[item]
+        return data
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        cc = cloud.CloudController()
+        meta_data = cc.get_metadata(req.remote_addr)
+        if meta_data is None:
+            _log.error('Failed to get metadata for ip: %s' % req.remote_addr)
+            raise webob.exc.HTTPNotFound()
+        data = self.lookup(path, meta_data)
+        if data is None:
+            raise webob.exc.HTTPNotFound()
+        return self.print_data(data)
-- 
cgit 


From 54122c0a156d1562be76dfde41bd62006f9ed426 Mon Sep 17 00:00:00 2001
From: Eric Day <eday@oddments.org>
Date: Wed, 22 Sep 2010 17:54:57 -0700
Subject: Various loose ends for endpoint and tornado removal cleanup,
 including cloudpipe API addition, rpc.call() cleanup by removing tornado
 ioloop, and fixing bin/* programs. Tornado still exists as part of some test
 cases and those should be reworked to not require it.

---
 nova/api/__init__.py           |  2 ++
 nova/api/cloudpipe/__init__.py | 68 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 nova/api/cloudpipe/__init__.py

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 821f1deea..ff9b94de9 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -24,6 +24,7 @@ import routes
 import webob.dec
 
 from nova import wsgi
+from nova.api import cloudpipe
 from nova.api import ec2
 from nova.api import rackspace
 
@@ -36,6 +37,7 @@ class API(wsgi.Router):
         mapper.connect("/", controller=self.versions)
         mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API())
         mapper.connect("/services/{path_info:.*}", controller=ec2.API())
+        mapper.connect("/cloudpipe/{path_info:.*}", controller=cloudpipe.API())
         super(API, self).__init__(mapper)
 
     @webob.dec.wsgify
diff --git a/nova/api/cloudpipe/__init__.py b/nova/api/cloudpipe/__init__.py
new file mode 100644
index 000000000..642f8ef6c
--- /dev/null
+++ b/nova/api/cloudpipe/__init__.py
@@ -0,0 +1,68 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+REST API Request Handlers for CloudPipe
+"""
+
+import logging
+import urllib
+import webob
+import webob.dec
+import webob.exc
+
+from nova import crypto
+from nova import wsgi
+from nova.auth import manager
+from nova.api.ec2 import cloud
+
+
+_log = logging.getLogger("api")
+_log.setLevel(logging.DEBUG)
+
+
+class API(wsgi.Application):
+
+    def __init__(self):
+        self.controller = cloud.CloudController()
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        if req.method == 'POST':
+            return self.sign_csr(req)
+        _log.debug("Cloudpipe path is %s" % req.path_info)
+        if req.path_info.endswith("/getca/"):
+            return self.send_root_ca(req)
+        return webob.exc.HTTPNotFound()
+
+    def get_project_id_from_ip(self, ip):
+        instance = self.controller.get_instance_by_ip(ip)
+        return instance['project_id']
+
+    def send_root_ca(self, req):
+        _log.debug("Getting root ca")
+        project_id = self.get_project_id_from_ip(req.remote_addr)
+        res = webob.Response()
+        res.headers["Content-Type"] = "text/plain"
+        res.body = crypto.fetch_ca(project_id)
+        return res
+
+    def sign_csr(self, req):
+        project_id = self.get_project_id_from_ip(req.remote_addr)
+        cert = self.str_params['cert']
+        return crypto.sign_csr(urllib.unquote(cert), project_id)
-- 
cgit 


From fed57c47da49a0457fce8fec3b59c9142e62785e Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Thu, 23 Sep 2010 13:59:33 +0200
Subject: Address Vishy's comments.

---
 nova/api/ec2/cloud.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 046aee14a..0f0aa327c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -725,9 +725,9 @@ class CloudController(object):
 
         security_groups = []
         for security_group_name in security_group_arg:
-            group = db.security_group_get_by_project(context,
-                                                     context.project.id,
-                                                     security_group_name)
+            group = db.security_group_get_by_name(context,
+                                                  context.project.id,
+                                                  security_group_name)
             security_groups.append(group['id'])
 
         reservation_id = utils.generate_uid('r')
@@ -744,6 +744,7 @@ class CloudController(object):
         base_options['user_data'] = kwargs.get('user_data', '')
 
         type_data = INSTANCE_TYPES[instance_type]
+        base_options['instance_type'] = instance_type
         base_options['memory_mb'] = type_data['memory_mb']
         base_options['vcpus'] = type_data['vcpus']
         base_options['local_gb'] = type_data['local_gb']
-- 
cgit 


From d98c663d3e521d45586ed3922d93e0ca612a5639 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 23 Sep 2010 09:06:45 -0400
Subject: Added FLAGS.FAKE_subdomain letting you manually set the subdomain for
 testing on localhost.

---
 nova/api/__init__.py | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index a0be05d86..8e4d844b2 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -34,6 +34,8 @@ flags.DEFINE_string('rsapi_subdomain', 'rs',
                     'subdomain running the RS API')
 flags.DEFINE_string('ec2api_subdomain', 'ec2', 
                     'subdomain running the EC2 API')
+flags.DEFINE_string('FAKE_subdomain', None, 
+                    'set to rs or ec2 to fake the subdomain of the host for testing')
 FLAGS = flags.FLAGS
 
 
@@ -41,17 +43,26 @@ class API(wsgi.Router):
     """Routes top-level requests to the appropriate controller."""
 
     def __init__(self):
+        rsdomain =  {'sub_domain': [FLAGS.rsapi_subdomain]}
+        ec2domain = {'sub_domain': [FLAGS.ec2api_subdomain]}
+        # If someone wants to pretend they're hitting the RS subdomain
+        # on their local box, they can set FAKE_subdomain to 'rs', which
+        # removes subdomain restrictions from the RS routes below.
+        if FLAGS.FAKE_subdomain == 'rs':
+            rsdomain = {}
+        elif FLAGS.FAKE_subdomain == 'ec2':
+            ec2domain = {}
         mapper = routes.Mapper()
         mapper.sub_domains = True
         mapper.connect("/", controller=self.rsapi_versions, 
-                            conditions={'sub_domain': [FLAGS.rsapi_subdomain]})
+                            conditions=rsdomain)
         mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API(),
-                            conditions={'sub_domain': [FLAGS.rsapi_subdomain]})
+                            conditions=rsdomain)
 
         mapper.connect("/", controller=self.ec2api_versions,
-                            conditions={'sub_domain': [FLAGS.ec2api_subdomain]})
+                            conditions=ec2domain)
         mapper.connect("/services/{path_info:.*}", controller=ec2.API(),
-                            conditions={'sub_domain': [FLAGS.ec2api_subdomain]})
+                            conditions=ec2domain)
         mrh = metadatarequesthandler.MetadataRequestHandler()
         for s in ['/latest',
                   '/2009-04-04',
@@ -64,7 +75,7 @@ class API(wsgi.Router):
                   '/2007-01-19',
                   '/1.0']:
             mapper.connect('%s/{path_info:.*}' % s, controller=mrh,
-                           conditions={'subdomain': FLAGS.ec2api_subdomain})
+                           conditions=ec2domain)
         super(API, self).__init__(mapper)
 
     @webob.dec.wsgify
-- 
cgit 


From c9ac49b2425b932f60a87da80887d4556806ca60 Mon Sep 17 00:00:00 2001
From: Eric Day <eday@oddments.org>
Date: Thu, 23 Sep 2010 11:21:14 -0700
Subject: Fixed cloudpipe lib init.

---
 nova/api/cloudpipe/__init__.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova/api')

diff --git a/nova/api/cloudpipe/__init__.py b/nova/api/cloudpipe/__init__.py
index 642f8ef6c..6d40990a8 100644
--- a/nova/api/cloudpipe/__init__.py
+++ b/nova/api/cloudpipe/__init__.py
@@ -51,6 +51,7 @@ class API(wsgi.Application):
         return webob.exc.HTTPNotFound()
 
     def get_project_id_from_ip(self, ip):
+        # TODO(eday): This was removed with the ORM branch, fix!
         instance = self.controller.get_instance_by_ip(ip)
         return instance['project_id']
 
-- 
cgit 


From 2b30ffe2f3c79e3701487d18fe1d4eef671aa335 Mon Sep 17 00:00:00 2001
From: Eric Day <eday@oddments.org>
Date: Thu, 23 Sep 2010 13:18:40 -0700
Subject: Applied vish's fixes.

---
 nova/api/ec2/metadatarequesthandler.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/metadatarequesthandler.py b/nova/api/ec2/metadatarequesthandler.py
index 229e5a78d..08a8040ca 100644
--- a/nova/api/ec2/metadatarequesthandler.py
+++ b/nova/api/ec2/metadatarequesthandler.py
@@ -18,6 +18,8 @@
 
 """Metadata request handler."""
 
+import logging
+
 import webob.dec
 import webob.exc
 
@@ -63,9 +65,9 @@ class MetadataRequestHandler(object):
         cc = cloud.CloudController()
         meta_data = cc.get_metadata(req.remote_addr)
         if meta_data is None:
-            _log.error('Failed to get metadata for ip: %s' % req.remote_addr)
+            logging.error('Failed to get metadata for ip: %s' % req.remote_addr)
             raise webob.exc.HTTPNotFound()
-        data = self.lookup(path, meta_data)
+        data = self.lookup(req.path_info, meta_data)
         if data is None:
             raise webob.exc.HTTPNotFound()
         return self.print_data(data)
-- 
cgit 


From a70632890c610ece766bfd3c31eea4bc6eb4a316 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 23 Sep 2010 17:06:23 -0400
Subject: Apply vish's patch

---
 nova/api/ec2/__init__.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index b041787c2..f0aa57ee4 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -166,8 +166,8 @@ class Authorizer(wsgi.Middleware):
                 'ModifyImageAttribute': ['projectmanager', 'sysadmin'],
             },
             'AdminController': {
-                # All actions have the same permission: [] (the default)
-                # admins will be allowed to run them
+                # All actions have the same permission: ['none'] (the default)
+                # superusers will be allowed to run them
                 # all others will get HTTPUnauthorized.
             },
         }
@@ -177,8 +177,7 @@ class Authorizer(wsgi.Middleware):
         context = req.environ['ec2.context']
         controller_name = req.environ['ec2.controller'].__class__.__name__
         action = req.environ['ec2.action']
-        allowed_roles = self.action_roles[controller_name].get(action, [])
-        allowed_roles.extend(FLAGS.superuser_roles)
+        allowed_roles = self.action_roles[controller_name].get(action, ['none'])
         if self._matches_any_role(context, allowed_roles):
             return self.application
         else:
@@ -186,6 +185,8 @@ class Authorizer(wsgi.Middleware):
 
     def _matches_any_role(self, context, roles):
         """Return True if any role in roles is allowed in context."""
+        if context.user.is_superuser():
+            return True
         if 'all' in roles:
             return True
         if 'none' in roles:
-- 
cgit 


From 307b16447a16e438d78b8149418c0ef728c5300e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Sat, 25 Sep 2010 13:00:19 -0500
Subject: Minor changes to be committed so trunk can be merged in

---
 nova/api/rackspace/servers.py | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 08b6768f9..9243f3ae6 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -22,11 +22,14 @@ from nova import rpc
 from nova import utils
 from nova import compute
 from nova.api.rackspace import base
+from nova.api.rackspace import _id_translator
 from webob import exc
 from nova import flags
 
 FLAGS = flags.FLAGS
 
+class ServersContext(object): pass
+
 class Controller(base.Controller):
     _serialization_metadata = {
         'application/xml': {
@@ -39,12 +42,16 @@ class Controller(base.Controller):
         }
     }
 
-    def __init__(self):
-        self.instdir = compute.InstanceDirectory()
+    def __init__(self, db_driver=None):
+        self.context = ServersContext()
+        if not db_driver:
+            db_driver = FLAGS.db_driver
+        self.db = utils.import_object(db_driver)
 
     def index(self, req):
-        allowed_keys = [ 'id', 'name']
-        return [_entity_inst(inst, allowed_keys) for inst in instdir.all]
+        unfiltered = [ 'id', 'name']
+        instance_list = self.instance_get_all(self.context)
+        return [_entity_inst(inst, unfiltered) for inst in instance_list]
 
     def detail(self, req):
         return [_entity_inst(inst) for inst in instdir.all]
@@ -79,12 +86,21 @@ class Controller(base.Controller):
         instance.save()
         return exc.HTTPNoContent()
 
+    def _id_translator(self):
+        service = nova.image.service.ImageService.load()
+        return _id_translator.RackspaceAPIIdTranslator(
+            "image", self.service.__class__.__name__)
+
     def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
         inst = {}
+
+        image_id = env['server']['imageId']
+        opaque_id = self._id_translator.from_rs_id(image_id)
+
         inst['name'] = env['server']['name']
-        inst['image_id'] = env['server']['imageId']
+        inst['image_id'] = opaque_id
         inst['instance_type'] = env['server']['flavorId']
         inst['user_id'] = env['user']['id']
 
-- 
cgit 


From e627748aec6a4747e22975d6cd59c8f20bc00c70 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Sat, 25 Sep 2010 13:35:23 -0500
Subject: Modification of test stubbing to match new domain requirements for
 the router, and removal of the unnecessary rackspace base controller

---
 nova/api/rackspace/base.py           | 24 ------------------------
 nova/api/rackspace/flavors.py        |  3 ++-
 nova/api/rackspace/images.py         |  3 ++-
 nova/api/rackspace/servers.py        | 29 ++++++++++++++++-------------
 nova/api/rackspace/sharedipgroups.py |  4 +++-
 5 files changed, 23 insertions(+), 40 deletions(-)
 delete mode 100644 nova/api/rackspace/base.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/base.py b/nova/api/rackspace/base.py
deleted file mode 100644
index 5e5bd6f54..000000000
--- a/nova/api/rackspace/base.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from nova import wsgi
-
-
-class Controller(wsgi.Controller):
-    """TODO(eday): Base controller for all rackspace controllers. What is this
-    for? Is this just Rackspace specific? """
-    pass
diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 60b35c939..024011a71 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -17,9 +17,10 @@
 
 from nova.api.rackspace import base
 from nova.compute import instance_types
+from nova import wsgi
 from webob import exc
 
-class Controller(base.Controller):
+class Controller(wsgi.Controller):
     """Flavor controller for the Rackspace API."""
 
     _serialization_metadata = {
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 2f3e928b9..9aaec52e2 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -16,11 +16,12 @@
 #    under the License.
 
 import nova.image.service
+from nova import wsgi
 from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
 from webob import exc
 
-class Controller(base.Controller):
+class Controller(wsgi.Controller):
 
     _serialization_metadata = {
         'application/xml': {
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 9243f3ae6..d94295861 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -21,16 +21,14 @@ from nova import flags
 from nova import rpc
 from nova import utils
 from nova import compute
+from nova import flags
 from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
 from webob import exc
-from nova import flags
 
 FLAGS = flags.FLAGS
 
-class ServersContext(object): pass
-
-class Controller(base.Controller):
+class Controller(wsgi.Controller):
     _serialization_metadata = {
         'application/xml': {
             "plurals": "servers",
@@ -43,27 +41,30 @@ class Controller(base.Controller):
     }
 
     def __init__(self, db_driver=None):
-        self.context = ServersContext()
         if not db_driver:
             db_driver = FLAGS.db_driver
         self.db = utils.import_object(db_driver)
 
     def index(self, req):
         unfiltered = [ 'id', 'name']
-        instance_list = self.instance_get_all(self.context)
-        return [_entity_inst(inst, unfiltered) for inst in instance_list]
+        instance_list = self.db.instance_get_all(None)
+        res = [self._entity_inst(inst, unfiltered) for inst in \ 
+            instance_list]
+        return self._entity_list(res)
 
     def detail(self, req):
-        return [_entity_inst(inst) for inst in instdir.all]
+        res = [self._entity_inst(inst) for inst in \
+                self.db.instance_get_all(None)]
+        return self._entity_list(res)
 
     def show(self, req, id):
-        inst = self.instdir.get(id)
+        inst = self.db.instance_get(None, id)
         if inst:
-            return _entity_inst(inst)
+            return self._entity_inst(inst)
         raise exc.HTTPNotFound()
 
     def delete(self, req, id):
-        instance = self.instdir.get(id)
+        instance = self.db.instance_get(None, id)
 
         if not instance:
             return exc.HTTPNotFound()
@@ -79,7 +80,7 @@ class Controller(base.Controller):
         return _entity_inst(inst)
 
     def update(self, req, id):
-        instance = self.instdir.get(instance_id)
+        instance = self.db.instance_get(None, id)
         if not instance:
             return exc.HTTPNotFound()
         instance.update(kwargs['server'])
@@ -107,7 +108,6 @@ class Controller(base.Controller):
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
 
-        # TODO(dietz) Do we need any of these?
         inst['project_id'] = env['project']['id']
         inst['reservation_id'] = reservation
         reservation = utils.generate_uid('r')
@@ -125,6 +125,9 @@ class Controller(base.Controller):
         inst.save()
         return _entity_inst(inst)
 
+    def _entity_list(self, entities):
+        return dict(servers=entities)
+
     def _entity_inst(self, inst, allowed_keys=None):
         """ Maps everything to Rackspace-like attributes for return"""
 
diff --git a/nova/api/rackspace/sharedipgroups.py b/nova/api/rackspace/sharedipgroups.py
index 986f11434..4d2d0ede1 100644
--- a/nova/api/rackspace/sharedipgroups.py
+++ b/nova/api/rackspace/sharedipgroups.py
@@ -15,4 +15,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-class Controller(object): pass
+from nova import wsgi
+
+class Controller(wsgi.Controller): pass
-- 
cgit 


From e6ada2403cb83070c270a96c7e371513d21e27f4 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Mon, 27 Sep 2010 15:13:11 +0200
Subject: If an instance never got scheduled for whatever reason, its host will
 turn up as None. Filter those out to make sure refresh works.

---
 nova/api/ec2/cloud.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 0f0aa327c..7330967fa 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -116,7 +116,8 @@ class CloudController(object):
         return result
 
     def _trigger_refresh_security_group(self, security_group):
-        nodes = set([instance.host for instance in security_group.instances])
+        nodes = set([instance['host'] for instance in security_group.instances
+                       if instance['host'] is not None])
         for node in nodes:
             rpc.call('%s.%s' % (FLAGS.compute_topic, node),
                      { "method": "refresh_security_group",
-- 
cgit 


From 1d83acca365b13319bddbd628725d7b666879091 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 27 Sep 2010 12:58:35 -0500
Subject: More re-work around the ORM changes and testing

---
 nova/api/rackspace/servers.py | 47 ++++++++++++++++++++++---------------------
 1 file changed, 24 insertions(+), 23 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index d94295861..7973fa770 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -16,6 +16,7 @@
 #    under the License.
 import time
 
+from nova import wsgi
 from nova import db
 from nova import flags
 from nova import rpc
@@ -29,13 +30,12 @@ from webob import exc
 FLAGS = flags.FLAGS
 
 class Controller(wsgi.Controller):
+
     _serialization_metadata = {
         'application/xml': {
-            "plurals": "servers",
             "attributes": {
                 "server": [ "id", "imageId", "name", "flavorId", "hostId", 
-                            "status", "progress", "addresses", "metadata", 
-                            "progress" ]
+                            "status", "progress", "progress" ]
             }
         }
     }
@@ -46,21 +46,19 @@ class Controller(wsgi.Controller):
         self.db = utils.import_object(db_driver)
 
     def index(self, req):
-        unfiltered = [ 'id', 'name']
         instance_list = self.db.instance_get_all(None)
-        res = [self._entity_inst(inst, unfiltered) for inst in \ 
-            instance_list]
+        res = [self._entity_inst(inst)['server'] for inst in instance_list]
         return self._entity_list(res)
 
     def detail(self, req):
-        res = [self._entity_inst(inst) for inst in \
+        res = [self._entity_detail(inst)['server'] for inst in \
                 self.db.instance_get_all(None)]
         return self._entity_list(res)
 
     def show(self, req, id):
         inst = self.db.instance_get(None, id)
         if inst:
-            return self._entity_inst(inst)
+            return self._entity_detail(inst)
         raise exc.HTTPNotFound()
 
     def delete(self, req, id):
@@ -128,25 +126,28 @@ class Controller(wsgi.Controller):
     def _entity_list(self, entities):
         return dict(servers=entities)
 
-    def _entity_inst(self, inst, allowed_keys=None):
+    def _entity_detail(self, inst):
         """ Maps everything to Rackspace-like attributes for return"""
+        inst_dir = {}
+
+        mapped_keys = dict(status='state_description', imageId='image_id', 
+            flavorId='instance_type', name='name')
 
-        translated_keys = dict(metadata={}, status=state_description,
-            id=instance_id, imageId=image_id, flavorId=instance_type,)
+        for k,v in mapped_keys.iteritems():
+            inst_dir[k] = inst[v]
 
-        for k,v in translated_keys.iteritems():
-            inst[k] = inst[v]
+        inst_dir['addresses'] = dict(public=[], private=[])
+        inst_dir['metadata'] = {}
+        inst_dir['hostId'] = ''
 
-        filtered_keys = ['instance_id', 'state_description', 'state',
-            'reservation_id', 'project_id', 'launch_time',
-            'bridge_name', 'mac_address', 'user_id']
+        return dict(server=inst_dir)
 
-        for key in filtered_keys:
-            del inst[key]
+    def _entity_inst(self, inst):
+        """ Filters all model attributes save for id and name """
+        return dict(server=dict(id=inst['id'], name=inst['name']))
 
-        if allowed_keys:
-            for key in inst.keys():
-                if key not in allowed_keys:
-                    del inst[key]
+    def _to_rs_power_state(self, inst):
+        pass
 
-        return dict(server=inst)
+    def _from_rs_power_state(self, inst):
+        pass
-- 
cgit 


From 523f1c95ac12ed4782476c3273b337601ad8b6ae Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Mon, 27 Sep 2010 21:49:24 +0200
Subject: If neither a security group nor a cidr has been passed, assume
 cidr=0.0.0.0/0

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 7330967fa..4cf2666a5 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -301,7 +301,7 @@ class CloudController(object):
             IPy.IP(cidr_ip)
             values['cidr'] = cidr_ip
         else:
-            return { 'return': False }
+            values['cidr'] = '0.0.0.0/0'
 
         if ip_protocol and from_port and to_port:
             from_port   = int(from_port)
-- 
cgit 


From 0e6c3b6034ef4927e381b231bf120a4980512c4e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Mon, 27 Sep 2010 17:01:37 -0500
Subject: Power state mapping

---
 nova/api/rackspace/servers.py | 42 ++++++++++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 16 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 7973fa770..53824ee1b 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -14,8 +14,9 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-import time
 
+import time
+import nova.image.service
 from nova import wsgi
 from nova import db
 from nova import flags
@@ -23,6 +24,7 @@ from nova import rpc
 from nova import utils
 from nova import compute
 from nova import flags
+from nova.compute import power_state
 from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
 from webob import exc
@@ -31,6 +33,16 @@ FLAGS = flags.FLAGS
 
 class Controller(wsgi.Controller):
 
+    _power_mapping = { 
+        power_state.NOSTATE:  'build', 
+        power_state.RUNNING:  'active',
+        power_state.BLOCKED:  'active',
+        power_state.PAUSED:   'suspended',
+        power_state.SHUTDOWN: 'active',
+        power_state.SHUTOFF:  'active',
+        power_state.CRASHED:  'error'
+    }
+
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
@@ -74,7 +86,7 @@ class Controller(wsgi.Controller):
         rpc.cast(
             FLAGS.compute_topic, {
                 "method": "run_instance",
-                "args": {"instance_id": inst.instance_id}})
+                "args": {"instance_id": inst.id}})
         return _entity_inst(inst)
 
     def update(self, req, id):
@@ -121,33 +133,31 @@ class Controller(wsgi.Controller):
                                 'default')['bridge_name']
 
         inst.save()
-        return _entity_inst(inst)
+        return inst
+
+    def _filter_params(self, inst_dict):
+        pass
 
     def _entity_list(self, entities):
         return dict(servers=entities)
 
     def _entity_detail(self, inst):
         """ Maps everything to Rackspace-like attributes for return"""
-        inst_dir = {}
+        inst_dict = {}
 
-        mapped_keys = dict(status='state_description', imageId='image_id', 
+        mapped_keys = dict(status='state', imageId='image_id', 
             flavorId='instance_type', name='name')
 
         for k,v in mapped_keys.iteritems():
-            inst_dir[k] = inst[v]
+            inst_dict[k] = inst[v]
 
-        inst_dir['addresses'] = dict(public=[], private=[])
-        inst_dir['metadata'] = {}
-        inst_dir['hostId'] = ''
+        inst_dict['status'] = Controller._power_mapping[inst_dict['status']]
+        inst_dict['addresses'] = dict(public=[], private=[])
+        inst_dict['metadata'] = {}
+        inst_dict['hostId'] = ''
 
-        return dict(server=inst_dir)
+        return dict(server=inst_dict)
 
     def _entity_inst(self, inst):
         """ Filters all model attributes save for id and name """
         return dict(server=dict(id=inst['id'], name=inst['name']))
-
-    def _to_rs_power_state(self, inst):
-        pass
-
-    def _from_rs_power_state(self, inst):
-        pass
-- 
cgit 


From 2f72b2a9fc9fee508b16c0b96285124279ef89ca Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 28 Sep 2010 00:23:49 -0500
Subject: More cleanup, backup_schedules controller, server details and the
 beginnings of the servers action route

---
 nova/api/rackspace/__init__.py         | 17 +++++++++++++---
 nova/api/rackspace/backup_schedules.py | 37 ++++++++++++++++++++++++++++++++++
 nova/api/rackspace/flavors.py          |  1 -
 nova/api/rackspace/images.py           |  1 -
 nova/api/rackspace/servers.py          | 22 ++++++++++++--------
 5 files changed, 65 insertions(+), 13 deletions(-)
 create mode 100644 nova/api/rackspace/backup_schedules.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index 63b0edc6a..a10a9c6df 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -35,6 +35,7 @@ from nova.api.rackspace import flavors
 from nova.api.rackspace import images
 from nova.api.rackspace import ratelimiting
 from nova.api.rackspace import servers
+from nova.api.rackspace import backup_schedules
 from nova.api.rackspace import sharedipgroups
 from nova.auth import manager
 
@@ -67,8 +68,10 @@ class AuthMiddleware(wsgi.Middleware):
 
         if not user:
             return webob.exc.HTTPUnauthorized()
-        context = {'user': user}
-        req.environ['nova.context'] = context
+
+        if not req.environ.has_key('nova.context'):
+            req.environ['nova.context'] = {}
+        req.environ['nova.context']['user'] = user
         return self.application
 
 class RateLimitingMiddleware(wsgi.Middleware):
@@ -146,11 +149,19 @@ class APIRouter(wsgi.Router):
     def __init__(self):
         mapper = routes.Mapper()
         mapper.resource("server", "servers", controller=servers.Controller(),
-                        collection={'detail': 'GET'})
+                        collection={ 'detail': 'GET'},
+                        member={'action':'POST'})
+
+        mapper.resource("backup_schedule", "backup_schedules", 
+                        controller=backup_schedules.Controller(),
+                        parent_resource=dict(member_name='server', 
+                        collection_name = 'servers')) 
+
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
         mapper.resource("flavor", "flavors", controller=flavors.Controller(),
                         collection={'detail': 'GET'})
         mapper.resource("sharedipgroup", "sharedipgroups",
                         controller=sharedipgroups.Controller())
+
         super(APIRouter, self).__init__(mapper)
diff --git a/nova/api/rackspace/backup_schedules.py b/nova/api/rackspace/backup_schedules.py
new file mode 100644
index 000000000..a18dfb87c
--- /dev/null
+++ b/nova/api/rackspace/backup_schedules.py
@@ -0,0 +1,37 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import time
+import nova.image.service
+from nova import wsgi
+from nova.api.rackspace import _id_translator
+from webob import exc
+
+class Controller(wsgi.Controller):
+    def __init__(self):
+        pass
+
+    def index(self, req, server_id):
+        return exc.HTTPNotFound()
+
+    def create(self, req, server_id):
+        """ No actual update method required, since the existing API allows
+        both create and update through a POST """
+        return exc.HTTPNotFound()
+
+    def delete(self, req, server_id):
+        return exc.HTTPNotFound()
diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 024011a71..3bcf170e5 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -15,7 +15,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from nova.api.rackspace import base
 from nova.compute import instance_types
 from nova import wsgi
 from webob import exc
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 9aaec52e2..10e15de3f 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -17,7 +17,6 @@
 
 import nova.image.service
 from nova import wsgi
-from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
 from webob import exc
 
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 53824ee1b..d825e734e 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -25,7 +25,6 @@ from nova import utils
 from nova import compute
 from nova import flags
 from nova.compute import power_state
-from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
 from webob import exc
 
@@ -63,11 +62,12 @@ class Controller(wsgi.Controller):
         return self._entity_list(res)
 
     def detail(self, req):
-        res = [self._entity_detail(inst)['server'] for inst in \
+        res = [self._entity_detail(inst)['server'] for inst in 
                 self.db.instance_get_all(None)]
         return self._entity_list(res)
 
     def show(self, req, id):
+        user = req.environ['nova.context']['user']
         inst = self.db.instance_get(None, id)
         if inst:
             return self._entity_detail(inst)
@@ -75,10 +75,9 @@ class Controller(wsgi.Controller):
 
     def delete(self, req, id):
         instance = self.db.instance_get(None, id)
-
         if not instance:
             return exc.HTTPNotFound()
-        instance.destroy()
+        self.db.instance_destroy(None, id)
         return exc.HTTPAccepted()
 
     def create(self, req):
@@ -93,10 +92,17 @@ class Controller(wsgi.Controller):
         instance = self.db.instance_get(None, id)
         if not instance:
             return exc.HTTPNotFound()
-        instance.update(kwargs['server'])
-        instance.save()
+
+        attrs = req.environ['nova.context'].get('model_attributes', None)
+        if attrs:
+            self.db.instance_update(None, id, attrs)
         return exc.HTTPNoContent()
 
+    def action(self, req, id):
+        """ multi-purpose method used to reboot, rebuild, and 
+        resize a server """
+        return {}
+
     def _id_translator(self):
         service = nova.image.service.ImageService.load()
         return _id_translator.RackspaceAPIIdTranslator(
@@ -132,7 +138,7 @@ class Controller(wsgi.Controller):
                                 inst['project_id'],
                                 'default')['bridge_name']
 
-        inst.save()
+        self.db.instance_create(None, inst)
         return inst
 
     def _filter_params(self, inst_dict):
@@ -146,7 +152,7 @@ class Controller(wsgi.Controller):
         inst_dict = {}
 
         mapped_keys = dict(status='state', imageId='image_id', 
-            flavorId='instance_type', name='name')
+            flavorId='instance_type', name='name', id='id')
 
         for k,v in mapped_keys.iteritems():
             inst_dict[k] = inst[v]
-- 
cgit 


From 7e25838ea1965231df09f29675fc3ab40e194483 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 28 Sep 2010 00:44:32 -0500
Subject: db api call to get instances by user and user checking in each of the
 server actions

---
 nova/api/rackspace/servers.py | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index d825e734e..becac9140 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -57,28 +57,32 @@ class Controller(wsgi.Controller):
         self.db = utils.import_object(db_driver)
 
     def index(self, req):
-        instance_list = self.db.instance_get_all(None)
+        user_id = req.environ['nova.context']['user']['id']
+        instance_list = self.db.instance_get_all_by_user(None, user_id)
         res = [self._entity_inst(inst)['server'] for inst in instance_list]
         return self._entity_list(res)
 
     def detail(self, req):
+        user_id = req.environ['nova.context']['user']['id']
         res = [self._entity_detail(inst)['server'] for inst in 
-                self.db.instance_get_all(None)]
+                self.db.instance_get_all_by_user(None, user_id)]
         return self._entity_list(res)
 
     def show(self, req, id):
-        user = req.environ['nova.context']['user']
+        user_id = req.environ['nova.context']['user']['id']
         inst = self.db.instance_get(None, id)
         if inst:
-            return self._entity_detail(inst)
+            if inst.user_id == user_id:
+                return self._entity_detail(inst)
         raise exc.HTTPNotFound()
 
     def delete(self, req, id):
+        user_id = req.environ['nova.context']['user']['id']
         instance = self.db.instance_get(None, id)
-        if not instance:
-            return exc.HTTPNotFound()
-        self.db.instance_destroy(None, id)
-        return exc.HTTPAccepted()
+        if instance and instance['user_id'] == user_id:
+            self.db.instance_destroy(None, id)
+            return exc.HTTPAccepted()
+        return exc.HTTPNotFound()
 
     def create(self, req):
         inst = self._build_server_instance(req)
@@ -95,7 +99,7 @@ class Controller(wsgi.Controller):
 
         attrs = req.environ['nova.context'].get('model_attributes', None)
         if attrs:
-            self.db.instance_update(None, id, attrs)
+            self.db.instance_update(None, id, self._filter_params(attrs))
         return exc.HTTPNoContent()
 
     def action(self, req, id):
@@ -142,7 +146,12 @@ class Controller(wsgi.Controller):
         return inst
 
     def _filter_params(self, inst_dict):
-        pass
+        keys = ['name', 'adminPass']
+        new_attrs = {}
+        for k in keys:
+            if inst_dict.has_key(k):
+                new_attrs[k] = inst_dict[k]
+        return new_attrs
 
     def _entity_list(self, entities):
         return dict(servers=entities)
-- 
cgit 


From 663ed27a2d7b3cb3a5290e0516eb8d602d7e65ba Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 28 Sep 2010 12:56:01 -0500
Subject: Testing testing testing

---
 nova/api/rackspace/_id_translator.py |  2 +-
 nova/api/rackspace/servers.py        | 22 +++++++++++++++++-----
 2 files changed, 18 insertions(+), 6 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/_id_translator.py b/nova/api/rackspace/_id_translator.py
index aec5fb6a5..333aa8434 100644
--- a/nova/api/rackspace/_id_translator.py
+++ b/nova/api/rackspace/_id_translator.py
@@ -37,6 +37,6 @@ class RackspaceAPIIdTranslator(object):
                 # every int id be used.)
                 return int(self._store.hget(self._fwd_key, str(opaque_id)))
 
-    def from_rs_id(self, strategy_name, rs_id):
+    def from_rs_id(self, rs_id):
         """Convert a Rackspace id to a strategy-specific one."""
         return self._store.hget(self._rev_key, rs_id)
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index becac9140..dec369ef0 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -85,7 +85,11 @@ class Controller(wsgi.Controller):
         return exc.HTTPNotFound()
 
     def create(self, req):
+        if not req.environ.has_key('inst_dict'):
+            return exc.HTTPUnprocessableEntity()
+
         inst = self._build_server_instance(req)
+
         rpc.cast(
             FLAGS.compute_topic, {
                 "method": "run_instance",
@@ -93,6 +97,9 @@ class Controller(wsgi.Controller):
         return _entity_inst(inst)
 
     def update(self, req, id):
+        if not req.environ.has_key('inst_dict'):
+            return exc.HTTPUnprocessableEntity()
+
         instance = self.db.instance_get(None, id)
         if not instance:
             return exc.HTTPNotFound()
@@ -105,25 +112,30 @@ class Controller(wsgi.Controller):
     def action(self, req, id):
         """ multi-purpose method used to reboot, rebuild, and 
         resize a server """
-        return {}
+        if not req.environ.has_key('inst_dict'):
+            return exc.HTTPUnprocessableEntity()
 
-    def _id_translator(self):
+    def translator_instance(self):
         service = nova.image.service.ImageService.load()
         return _id_translator.RackspaceAPIIdTranslator(
-            "image", self.service.__class__.__name__)
+                "image", service.__class__.__name__)
 
     def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
         inst = {}
 
+        env = req.environ['inst_dict']
+
         image_id = env['server']['imageId']
-        opaque_id = self._id_translator.from_rs_id(image_id)
+        opaque_id = self.translator_instance().from_rs_id(image_id)
 
         inst['name'] = env['server']['name']
         inst['image_id'] = opaque_id
         inst['instance_type'] = env['server']['flavorId']
-        inst['user_id'] = env['user']['id']
+
+        user_id = req.environ['nova.context']['user']['id']
+        inst['user_id'] = user_id
 
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
-- 
cgit 


From 7ebf1e292b4840e0da4190d2aaf3fa8fc5439846 Mon Sep 17 00:00:00 2001
From: Devin Carlen <devin.carlen@gmail.com>
Date: Tue, 28 Sep 2010 11:49:20 -0700
Subject: Implemented random instance and volume strings for ec2 api

---
 nova/api/ec2/cloud.py | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 367511e3b..88d53527c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -143,7 +143,7 @@ class CloudController(object):
                 },
                 'hostname': hostname,
                 'instance-action': 'none',
-                'instance-id': instance_ref['str_id'],
+                'instance-id': instance_ref['ec2_id'],
                 'instance-type': instance_ref['instance_type'],
                 'local-hostname': hostname,
                 'local-ipv4': address,
@@ -245,7 +245,7 @@ class CloudController(object):
 
     def get_console_output(self, context, instance_id, **kwargs):
         # instance_id is passed in as a list of instances
-        instance_ref = db.instance_get_by_str(context, instance_id[0])
+        instance_ref = db.instance_get_by_ec2_id(context, instance_id[0])
         return rpc.call('%s.%s' % (FLAGS.compute_topic,
                                    instance_ref['host']),
                         {"method": "get_console_output",
@@ -264,7 +264,7 @@ class CloudController(object):
 
     def _format_volume(self, context, volume):
         v = {}
-        v['volumeId'] = volume['str_id']
+        v['volumeId'] = volume['ec2_id']
         v['status'] = volume['status']
         v['size'] = volume['size']
         v['availabilityZone'] = volume['availability_zone']
@@ -282,7 +282,7 @@ class CloudController(object):
                                    'device': volume['mountpoint'],
                                    'instanceId': volume['instance_id'],
                                    'status': 'attached',
-                                   'volume_id': volume['str_id']}]
+                                   'volume_id': volume['ec2_id']}]
         else:
             v['attachmentSet'] = [{}]
         return v
@@ -314,13 +314,13 @@ class CloudController(object):
 
 
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
-        volume_ref = db.volume_get_by_str(context, volume_id)
+        volume_ref = db.volume_get_by_ec2_id(context, volume_id)
         # TODO(vish): abstract status checking?
         if volume_ref['status'] != "available":
             raise exception.ApiError("Volume status must be available")
         if volume_ref['attach_status'] == "attached":
             raise exception.ApiError("Volume is already attached")
-        instance_ref = db.instance_get_by_str(context, instance_id)
+        instance_ref = db.instance_get_by_ec2_id(context, instance_id)
         host = instance_ref['host']
         rpc.cast(db.queue_get_for(context, FLAGS.compute_topic, host),
                                 {"method": "attach_volume",
@@ -336,7 +336,7 @@ class CloudController(object):
                 'volumeId': volume_ref['id']}
 
     def detach_volume(self, context, volume_id, **kwargs):
-        volume_ref = db.volume_get_by_str(context, volume_id)
+        volume_ref = db.volume_get_by_ec2_id(context, volume_id)
         instance_ref = db.volume_get_instance(context, volume_ref['id'])
         if not instance_ref:
             raise exception.ApiError("Volume isn't attached to anything!")
@@ -356,7 +356,7 @@ class CloudController(object):
             db.volume_detached(context)
         return {'attachTime': volume_ref['attach_time'],
                 'device': volume_ref['mountpoint'],
-                'instanceId': instance_ref['str_id'],
+                'instanceId': instance_ref['ec2_id'],
                 'requestId': context.request_id,
                 'status': volume_ref['attach_status'],
                 'volumeId': volume_ref['id']}
@@ -395,7 +395,7 @@ class CloudController(object):
                 if instance['image_id'] == FLAGS.vpn_image_id:
                     continue
             i = {}
-            i['instanceId'] = instance['str_id']
+            i['instanceId'] = instance['ec2_id']
             i['imageId'] = instance['image_id']
             i['instanceState'] = {
                 'code': instance['state'],
@@ -446,7 +446,7 @@ class CloudController(object):
             instance_id = None
             if (floating_ip_ref['fixed_ip']
                 and floating_ip_ref['fixed_ip']['instance']):
-                instance_id = floating_ip_ref['fixed_ip']['instance']['str_id']
+                instance_id = floating_ip_ref['fixed_ip']['instance']['ec2_id']
             address_rv = {'public_ip': address,
                           'instance_id': instance_id}
             if context.user.is_admin():
@@ -481,7 +481,7 @@ class CloudController(object):
         return {'releaseResponse': ["Address released."]}
 
     def associate_address(self, context, instance_id, public_ip, **kwargs):
-        instance_ref = db.instance_get_by_str(context, instance_id)
+        instance_ref = db.instance_get_by_ec2_id(context, instance_id)
         fixed_ip_ref = db.fixed_ip_get_by_instance(context, instance_ref['id'])
         floating_ip_ref = db.floating_ip_get_by_address(context, public_ip)
         network_topic = self._get_network_topic(context)
@@ -589,7 +589,7 @@ class CloudController(object):
             inst = {}
             inst['mac_address'] = utils.generate_mac()
             inst['launch_index'] = num
-            inst['hostname'] = instance_ref['str_id']
+            inst['hostname'] = instance_ref['ec2_id']
             db.instance_update(context, inst_id, inst)
             address = self.network_manager.allocate_fixed_ip(context,
                                                              inst_id,
@@ -618,7 +618,7 @@ class CloudController(object):
         for id_str in instance_id:
             logging.debug("Going to try and terminate %s" % id_str)
             try:
-                instance_ref = db.instance_get_by_str(context, id_str)
+                instance_ref = db.instance_get_by_ec2_id(context, id_str)
             except exception.NotFound:
                 logging.warning("Instance %s was not found during terminate"
                                 % id_str)
@@ -664,7 +664,7 @@ class CloudController(object):
     def reboot_instances(self, context, instance_id, **kwargs):
         """instance_id is a list of instance ids"""
         for id_str in instance_id:
-            instance_ref = db.instance_get_by_str(context, id_str)
+            instance_ref = db.instance_get_by_ec2_id(context, id_str)
             host = instance_ref['host']
             rpc.cast(db.queue_get_for(context, FLAGS.compute_topic, host),
                      {"method": "reboot_instance",
@@ -674,7 +674,7 @@ class CloudController(object):
 
     def delete_volume(self, context, volume_id, **kwargs):
         # TODO: return error if not authorized
-        volume_ref = db.volume_get_by_str(context, volume_id)
+        volume_ref = db.volume_get_by_ec2_id(context, volume_id)
         if volume_ref['status'] != "available":
             raise exception.ApiError("Volume status must be available")
         now = datetime.datetime.utcnow()
-- 
cgit 


From 84fbad82d65b837d43f138e7a5acd24f182499e2 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Tue, 28 Sep 2010 12:09:17 -0700
Subject: move default group creation to api

---
 nova/api/ec2/cloud.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 4cf2666a5..d54562ec6 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -244,6 +244,7 @@ class CloudController(object):
         return True
 
     def describe_security_groups(self, context, group_name=None, **kwargs):
+        self._ensure_default_security_group(context)
         if context.user.is_admin():
             groups = db.security_group_get_all(context)
         else:
@@ -326,6 +327,7 @@ class CloudController(object):
         return values
 
     def revoke_security_group_ingress(self, context, group_name, **kwargs):
+        self._ensure_default_security_group(context)
         security_group = db.security_group_get_by_name(context,
                                                        context.project.id,
                                                        group_name)
@@ -351,6 +353,7 @@ class CloudController(object):
     #              for these operations, so support for newer API versions
     #              is sketchy.
     def authorize_security_group_ingress(self, context, group_name, **kwargs):
+        self._ensure_default_security_group(context)
         security_group = db.security_group_get_by_name(context,
                                                        context.project.id,
                                                        group_name)
@@ -383,6 +386,7 @@ class CloudController(object):
 
 
     def create_security_group(self, context, group_name, group_description):
+        self._ensure_default_security_group(context)
         if db.securitygroup_exists(context, context.project.id, group_name):
             raise exception.ApiError('group %s already exists' % group_name)
 
@@ -673,6 +677,18 @@ class CloudController(object):
                                             "project_id": context.project.id}})
         return db.queue_get_for(context, FLAGS.network_topic, host)
 
+    def _ensure_default_security_group(self, context):
+        try:
+            db.security_group_get_by_name(context,
+                                          context.project.id,
+                                          'default')
+        except exception.NotFound:
+            values = { 'name'        : 'default',
+                       'description' : 'default',
+                       'user_id'     : context.user.id,
+                       'project_id'  : context.project.id }
+            group = db.security_group_create({}, values)
+
     def run_instances(self, context, **kwargs):
         instance_type = kwargs.get('instance_type', 'm1.small')
         if instance_type not in INSTANCE_TYPES:
@@ -725,6 +741,7 @@ class CloudController(object):
             security_group_arg = [security_group_arg]
 
         security_groups = []
+        self._ensure_default_security_group(context)
         for security_group_name in security_group_arg:
             group = db.security_group_get_by_name(context,
                                                   context.project.id,
-- 
cgit 


From c1f7914f9d8c4f7687c67de37c5eda5a95245a0d Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Tue, 28 Sep 2010 16:41:39 -0400
Subject: Remove TODO, since apparently newer boto doesn't die on extra fields.

---
 nova/api/ec2/cloud.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 4defef87e..528380f0f 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -286,8 +286,6 @@ class CloudController(object):
         else:
             v['attachmentSet'] = [{}]
 
-        # TODO(todd): check api version and only pass back to nova-aware
-        #             clients
         v['display_name'] = volume['display_name']
         v['display_description'] = volume['display_description']
         return v
-- 
cgit 


From c80c0786baadf521c86ceff21288e3760aaea5bd Mon Sep 17 00:00:00 2001
From: Todd Willey <todd@ansolabs.com>
Date: Tue, 28 Sep 2010 16:47:29 -0400
Subject: Add authorization info for cloud endpoints.

---
 nova/api/ec2/__init__.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index f0aa57ee4..7a958f841 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -158,12 +158,14 @@ class Authorizer(wsgi.Middleware):
                 'RunInstances': ['projectmanager', 'sysadmin'],
                 'TerminateInstances': ['projectmanager', 'sysadmin'],
                 'RebootInstances': ['projectmanager', 'sysadmin'],
+                'UpdateInstance': ['projectmanager', 'sysadmin'],
                 'DeleteVolume': ['projectmanager', 'sysadmin'],
                 'DescribeImages': ['all'],
                 'DeregisterImage': ['projectmanager', 'sysadmin'],
                 'RegisterImage': ['projectmanager', 'sysadmin'],
                 'DescribeImageAttribute': ['all'],
                 'ModifyImageAttribute': ['projectmanager', 'sysadmin'],
+                'UpdateImage': ['projectmanager', 'sysadmin'],
             },
             'AdminController': {
                 # All actions have the same permission: ['none'] (the default)
-- 
cgit 


From 641b6ee5630ed00ee3e921769cd408a8603ff62b Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Tue, 28 Sep 2010 16:46:21 -0500
Subject: Merge prop fixes and pylint/pep8 cleanup

---
 nova/api/rackspace/__init__.py         |   2 +-
 nova/api/rackspace/auth.py             |   8 +-
 nova/api/rackspace/backup_schedules.py |   5 +-
 nova/api/rackspace/images.py           |   5 +-
 nova/api/rackspace/servers.py          | 141 ++++++++++++++++++---------------
 5 files changed, 91 insertions(+), 70 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index a10a9c6df..98802663f 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -31,11 +31,11 @@ import webob
 from nova import flags
 from nova import utils
 from nova import wsgi
+from nova.api.rackspace import backup_schedules
 from nova.api.rackspace import flavors
 from nova.api.rackspace import images
 from nova.api.rackspace import ratelimiting
 from nova.api.rackspace import servers
-from nova.api.rackspace import backup_schedules
 from nova.api.rackspace import sharedipgroups
 from nova.auth import manager
 
diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
index ce5a967eb..8bfb0753e 100644
--- a/nova/api/rackspace/auth.py
+++ b/nova/api/rackspace/auth.py
@@ -1,13 +1,15 @@
 import datetime
+import hashlib
 import json
 import time
+
 import webob.exc
 import webob.dec
-import hashlib
-from nova import flags
+
 from nova import auth
-from nova import manager
 from nova import db
+from nova import flags
+from nova import manager
 from nova import utils
 
 FLAGS = flags.FLAGS
diff --git a/nova/api/rackspace/backup_schedules.py b/nova/api/rackspace/backup_schedules.py
index a18dfb87c..46da778ee 100644
--- a/nova/api/rackspace/backup_schedules.py
+++ b/nova/api/rackspace/backup_schedules.py
@@ -16,10 +16,11 @@
 #    under the License.
 
 import time
-import nova.image.service
+from webob import exc
+
 from nova import wsgi
 from nova.api.rackspace import _id_translator
-from webob import exc
+import nova.image.service
 
 class Controller(wsgi.Controller):
     def __init__(self):
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 10e15de3f..11b058dec 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -15,10 +15,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import nova.image.service
+from webob import exc
+
 from nova import wsgi
 from nova.api.rackspace import _id_translator
-from webob import exc
+import nova.image.service
 
 class Controller(wsgi.Controller):
 
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index dec369ef0..4ab04bde7 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -16,23 +16,43 @@
 #    under the License.
 
 import time
-import nova.image.service
-from nova import wsgi
-from nova import db
+
+from webob import exc
+
 from nova import flags
 from nova import rpc
 from nova import utils
-from nova import compute
-from nova import flags
-from nova.compute import power_state
+from nova import wsgi
 from nova.api.rackspace import _id_translator
-from webob import exc
+from nova.compute import power_state
+import nova.image.service
 
 FLAGS = flags.FLAGS
 
-class Controller(wsgi.Controller):
 
-    _power_mapping = { 
+
+def translator_instance():
+    """ Helper method for initializing the image id translator """
+    service = nova.image.service.ImageService.load()
+    return _id_translator.RackspaceAPIIdTranslator(
+            "image", service.__class__.__name__)
+
+def _filter_params(inst_dict):
+    """ Extracts all updatable parameters for a server update request """
+    keys = ['name', 'adminPass']
+    new_attrs = {}
+    for k in keys:
+        if inst_dict.has_key(k):
+            new_attrs[k] = inst_dict[k]
+    return new_attrs
+
+def _entity_list(entities):
+    """ Coerces a list of servers into proper dictionary format """
+    return dict(servers=entities)
+
+def _entity_detail(inst):
+    """ Maps everything to Rackspace-like attributes for return"""
+    power_mapping = { 
         power_state.NOSTATE:  'build', 
         power_state.RUNNING:  'active',
         power_state.BLOCKED:  'active',
@@ -41,6 +61,28 @@ class Controller(wsgi.Controller):
         power_state.SHUTOFF:  'active',
         power_state.CRASHED:  'error'
     }
+    inst_dict = {}
+
+    mapped_keys = dict(status='state', imageId='image_id', 
+        flavorId='instance_type', name='server_name', id='id')
+
+    for k, v in mapped_keys.iteritems():
+        inst_dict[k] = inst[v]
+
+    inst_dict['status'] = power_mapping[inst_dict['status']]
+    inst_dict['addresses'] = dict(public=[], private=[])
+    inst_dict['metadata'] = {}
+    inst_dict['hostId'] = ''
+
+    return dict(server=inst_dict)
+
+def _entity_inst(inst):
+    """ Filters all model attributes save for id and name """
+    return dict(server=dict(id=inst['id'], name=inst['server_name']))
+
+class Controller(wsgi.Controller):
+    """ The Server API controller for the Openstack API """
+    
 
     _serialization_metadata = {
         'application/xml': {
@@ -54,37 +96,43 @@ class Controller(wsgi.Controller):
     def __init__(self, db_driver=None):
         if not db_driver:
             db_driver = FLAGS.db_driver
-        self.db = utils.import_object(db_driver)
+        self.db_driver = utils.import_object(db_driver)
+        super(Controller, self).__init__()
 
     def index(self, req):
+        """ Returns a list of server names and ids for a given user """
         user_id = req.environ['nova.context']['user']['id']
-        instance_list = self.db.instance_get_all_by_user(None, user_id)
-        res = [self._entity_inst(inst)['server'] for inst in instance_list]
-        return self._entity_list(res)
+        instance_list = self.db_driver.instance_get_all_by_user(None, user_id)
+        res = [_entity_inst(inst)['server'] for inst in instance_list]
+        return _entity_list(res)
 
     def detail(self, req):
+        """ Returns a list of server details for a given user """
         user_id = req.environ['nova.context']['user']['id']
-        res = [self._entity_detail(inst)['server'] for inst in 
-                self.db.instance_get_all_by_user(None, user_id)]
-        return self._entity_list(res)
+        res = [_entity_detail(inst)['server'] for inst in 
+                self.db_driver.instance_get_all_by_user(None, user_id)]
+        return _entity_list(res)
 
     def show(self, req, id):
+        """ Returns server details by server id """
         user_id = req.environ['nova.context']['user']['id']
-        inst = self.db.instance_get(None, id)
+        inst = self.db_driver.instance_get(None, id)
         if inst:
             if inst.user_id == user_id:
-                return self._entity_detail(inst)
+                return _entity_detail(inst)
         raise exc.HTTPNotFound()
 
     def delete(self, req, id):
+        """ Destroys a server """
         user_id = req.environ['nova.context']['user']['id']
-        instance = self.db.instance_get(None, id)
+        instance = self.db_driver.instance_get(None, id)
         if instance and instance['user_id'] == user_id:
-            self.db.instance_destroy(None, id)
+            self.db_driver.instance_destroy(None, id)
             return exc.HTTPAccepted()
         return exc.HTTPNotFound()
 
     def create(self, req):
+        """ Creates a new server for a given user """
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
@@ -93,20 +141,21 @@ class Controller(wsgi.Controller):
         rpc.cast(
             FLAGS.compute_topic, {
                 "method": "run_instance",
-                "args": {"instance_id": inst.id}})
+                "args": {"instance_id": inst['id']}})
         return _entity_inst(inst)
 
     def update(self, req, id):
+        """ Updates the server name or password """
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
-        instance = self.db.instance_get(None, id)
+        instance = self.db_driver.instance_get(None, id)
         if not instance:
             return exc.HTTPNotFound()
 
         attrs = req.environ['nova.context'].get('model_attributes', None)
         if attrs:
-            self.db.instance_update(None, id, self._filter_params(attrs))
+            self.db_driver.instance_update(None, id, _filter_params(attrs))
         return exc.HTTPNoContent()
 
     def action(self, req, id):
@@ -115,11 +164,6 @@ class Controller(wsgi.Controller):
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
-    def translator_instance(self):
-        service = nova.image.service.ImageService.load()
-        return _id_translator.RackspaceAPIIdTranslator(
-                "image", service.__class__.__name__)
-
     def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
@@ -128,9 +172,9 @@ class Controller(wsgi.Controller):
         env = req.environ['inst_dict']
 
         image_id = env['server']['imageId']
-        opaque_id = self.translator_instance().from_rs_id(image_id)
+        opaque_id = translator_instance().from_rs_id(image_id)
 
-        inst['name'] = env['server']['name']
+        inst['name'] = env['server']['server_name']
         inst['image_id'] = opaque_id
         inst['instance_type'] = env['server']['flavorId']
 
@@ -148,43 +192,16 @@ class Controller(wsgi.Controller):
                     inst['user_id'],
                     inst['project_id'],
                     mac=inst['mac_address'])
+
         inst['private_dns_name'] = str(address)
         inst['bridge_name'] = network.BridgedNetwork.get_network_for_project(
                                 inst['user_id'],
                                 inst['project_id'],
                                 'default')['bridge_name']
 
-        self.db.instance_create(None, inst)
+        ref = self.db_driver.instance_create(None, inst)
+        inst['id'] = ref.id
+        
         return inst
 
-    def _filter_params(self, inst_dict):
-        keys = ['name', 'adminPass']
-        new_attrs = {}
-        for k in keys:
-            if inst_dict.has_key(k):
-                new_attrs[k] = inst_dict[k]
-        return new_attrs
-
-    def _entity_list(self, entities):
-        return dict(servers=entities)
-
-    def _entity_detail(self, inst):
-        """ Maps everything to Rackspace-like attributes for return"""
-        inst_dict = {}
-
-        mapped_keys = dict(status='state', imageId='image_id', 
-            flavorId='instance_type', name='name', id='id')
-
-        for k,v in mapped_keys.iteritems():
-            inst_dict[k] = inst[v]
-
-        inst_dict['status'] = Controller._power_mapping[inst_dict['status']]
-        inst_dict['addresses'] = dict(public=[], private=[])
-        inst_dict['metadata'] = {}
-        inst_dict['hostId'] = ''
-
-        return dict(server=inst_dict)
-
-    def _entity_inst(self, inst):
-        """ Filters all model attributes save for id and name """
-        return dict(server=dict(id=inst['id'], name=inst['name']))
+    
-- 
cgit 


From 116f0fc0b18c6b04a86de5123d2985205d954093 Mon Sep 17 00:00:00 2001
From: Devin Carlen <devin.carlen@gmail.com>
Date: Tue, 28 Sep 2010 16:10:47 -0700
Subject: Fixed name property on instance model

---
 nova/api/ec2/cloud.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 88d53527c..05e8065f3 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -103,7 +103,7 @@ class CloudController(object):
         result = {}
         for instance in db.instance_get_by_project(None, project_id):
             if instance['fixed_ip']:
-                line = '%s slots=%d' % (instance['fixed_ip']['str_id'],
+                line = '%s slots=%d' % (instance['fixed_ip']['address'],
                     INSTANCE_TYPES[instance['instance_type']]['vcpus'])
                 key = str(instance['key_name'])
                 if key in result:
@@ -404,10 +404,10 @@ class CloudController(object):
             fixed_addr = None
             floating_addr = None
             if instance['fixed_ip']:
-                fixed_addr = instance['fixed_ip']['str_id']
+                fixed_addr = instance['fixed_ip']['address']
                 if instance['fixed_ip']['floating_ips']:
                     fixed = instance['fixed_ip']
-                    floating_addr = fixed['floating_ips'][0]['str_id']
+                    floating_addr = fixed['floating_ips'][0]['address']
             i['privateDnsName'] = fixed_addr
             i['publicDnsName'] = floating_addr
             i['dnsName'] = i['publicDnsName'] or i['privateDnsName']
@@ -442,7 +442,7 @@ class CloudController(object):
             iterator = db.floating_ip_get_by_project(context,
                                                      context.project.id)
         for floating_ip_ref in iterator:
-            address = floating_ip_ref['str_id']
+            address = floating_ip_ref['address']
             instance_id = None
             if (floating_ip_ref['fixed_ip']
                 and floating_ip_ref['fixed_ip']['instance']):
@@ -477,7 +477,7 @@ class CloudController(object):
         rpc.cast(network_topic,
                  {"method": "deallocate_floating_ip",
                   "args": {"context": None,
-                           "floating_address": floating_ip_ref['str_id']}})
+                           "floating_address": floating_ip_ref['address']}})
         return {'releaseResponse': ["Address released."]}
 
     def associate_address(self, context, instance_id, public_ip, **kwargs):
@@ -488,8 +488,8 @@ class CloudController(object):
         rpc.cast(network_topic,
                  {"method": "associate_floating_ip",
                   "args": {"context": None,
-                           "floating_address": floating_ip_ref['str_id'],
-                           "fixed_address": fixed_ip_ref['str_id']}})
+                           "floating_address": floating_ip_ref['address'],
+                           "fixed_address": fixed_ip_ref['address']}})
         return {'associateResponse': ["Address associated."]}
 
     def disassociate_address(self, context, public_ip, **kwargs):
@@ -498,7 +498,7 @@ class CloudController(object):
         rpc.cast(network_topic,
                  {"method": "disassociate_floating_ip",
                   "args": {"context": None,
-                           "floating_address": floating_ip_ref['str_id']}})
+                           "floating_address": floating_ip_ref['address']}})
         return {'disassociateResponse': ["Address disassociated."]}
 
     def _get_network_topic(self, context):
-- 
cgit 


From 05e3e188e03624884ed019fe9cd8f216c9262f98 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 28 Sep 2010 20:36:50 -0400
Subject: Fault support

---
 nova/api/rackspace/__init__.py |  9 ++++---
 nova/api/rackspace/auth.py     |  7 ++---
 nova/api/rackspace/faults.py   | 61 ++++++++++++++++++++++++++++++++++++++++++
 nova/api/rackspace/flavors.py  |  3 ++-
 nova/api/rackspace/images.py   |  7 ++---
 5 files changed, 77 insertions(+), 10 deletions(-)
 create mode 100644 nova/api/rackspace/faults.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index c24d08585..447037020 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -31,6 +31,7 @@ import webob
 from nova import flags
 from nova import utils
 from nova import wsgi
+from nova.api.rackspace import faults
 from nova.api.rackspace import flavors
 from nova.api.rackspace import images
 from nova.api.rackspace import ratelimiting
@@ -66,7 +67,7 @@ class AuthMiddleware(wsgi.Middleware):
         user = self.auth_driver.authorize_token(req.headers["X-Auth-Token"])
 
         if not user:
-            return webob.exc.HTTPUnauthorized()
+            return faults.Fault(webob.exc.HTTPUnauthorized())
         context = {'user': user}
         req.environ['nova.context'] = context
         return self.application
@@ -109,8 +110,10 @@ class RateLimitingMiddleware(wsgi.Middleware):
         delay = self.get_delay(action_name, username)
         if delay:
             # TODO(gundlach): Get the retry-after format correct.
-            raise webob.exc.HTTPRequestEntityTooLarge(headers={
-                    'Retry-After': time.time() + delay})
+            exc = webob.exc.HTTPRequestEntityTooLarge(
+                    explanation='Too many requests.',
+                    headers={'Retry-After': time.time() + delay})
+            raise faults.Fault(exc)
         return self.application
 
     def get_delay(self, action_name, username):
diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
index ce5a967eb..519263367 100644
--- a/nova/api/rackspace/auth.py
+++ b/nova/api/rackspace/auth.py
@@ -9,6 +9,7 @@ from nova import auth
 from nova import manager
 from nova import db
 from nova import utils
+from nova.api.rackspace import faults
 
 FLAGS = flags.FLAGS
 
@@ -34,13 +35,13 @@ class BasicApiAuthManager(object):
         # honor it
         path_info = req.path_info
         if len(path_info) > 1:
-            return webob.exc.HTTPUnauthorized()
+            return faults.Fault(webob.exc.HTTPUnauthorized())
 
         try:
             username, key = req.headers['X-Auth-User'], \
                 req.headers['X-Auth-Key']
         except KeyError:
-            return webob.exc.HTTPUnauthorized()
+            return faults.Fault(webob.exc.HTTPUnauthorized())
 
         username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
         token, user = self._authorize_user(username, key)
@@ -55,7 +56,7 @@ class BasicApiAuthManager(object):
             res.status = '204'
             return res
         else:
-            return webob.exc.HTTPUnauthorized()
+            return faults.Fault(webob.exc.HTTPUnauthorized())
 
     def authorize_token(self, token_hash):
         """ retrieves user information from the datastore given a token
diff --git a/nova/api/rackspace/faults.py b/nova/api/rackspace/faults.py
new file mode 100644
index 000000000..fd6bc3623
--- /dev/null
+++ b/nova/api/rackspace/faults.py
@@ -0,0 +1,61 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+import webob.dec
+
+from nova import wsgi
+
+
+class Fault(wsgi.Application):
+
+    """An RS API fault response."""
+
+    _fault_names = {
+            400: "badRequest",
+            401: "unauthorized",
+            403: "resizeNotAllowed",
+            404: "itemNotFound",
+            405: "badMethod",
+            409: "inProgress",
+            413: "overLimit",
+            415: "badMediaType",
+            501: "notImplemented",
+            503: "serviceUnavailable"}
+
+    def __init__(self, exception):
+        """Create a Fault for the given webob.exc.exception."""
+        self.exception = exception
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        """Generate a WSGI response based on self.exception."""
+        # Replace the body with fault details.
+        code = self.exception.status_int
+        fault_name = self._fault_names.get(code, "cloudServersFault")
+        fault_data = {
+            fault_name: {
+                'code': code,
+                'message': self.exception.explanation}}
+        if code == 413:
+            retry = self.exception.headers['Retry-After']
+            fault_data[fault_name]['retryAfter'] = retry
+        # 'code' is an attribute on the fault tag itself 
+        metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
+        serializer = wsgi.Serializer(req.environ, metadata)
+        self.exception.body = serializer.to_content_type(fault_data)
+        return self.exception
diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 60b35c939..6cc57be33 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 from nova.api.rackspace import base
+from nova.api.rackspace import faults
 from nova.compute import instance_types
 from webob import exc
 
@@ -47,7 +48,7 @@ class Controller(base.Controller):
                 item = dict(ram=val['memory_mb'], disk=val['local_gb'],
                             id=val['flavorid'], name=name)
                 return dict(flavor=item)
-        raise exc.HTTPNotFound()
+        raise faults.Fault(exc.HTTPNotFound())
 
     def _all_ids(self):
         """Return the list of all flavorids."""
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 2f3e928b9..1c50d0bec 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -18,6 +18,7 @@
 import nova.image.service
 from nova.api.rackspace import base
 from nova.api.rackspace import _id_translator
+from nova.api.rackspace import faults
 from webob import exc
 
 class Controller(base.Controller):
@@ -57,14 +58,14 @@ class Controller(base.Controller):
 
     def delete(self, req, id):
         # Only public images are supported for now.
-        raise exc.HTTPNotFound()
+        raise faults.Fault(exc.HTTPNotFound())
 
     def create(self, req):
         # Only public images are supported for now, so a request to
         # make a backup of a server cannot be supproted.
-        raise exc.HTTPNotFound()
+        raise faults.Fault(exc.HTTPNotFound())
 
     def update(self, req, id):
         # Users may not modify public images, and that's all that 
         # we support for now.
-        raise exc.HTTPNotFound()
+        raise faults.Fault(exc.HTTPNotFound())
-- 
cgit 


From c53af2fc9d9803cebc7f4078b8f772476a09df81 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Tue, 28 Sep 2010 18:47:47 -0700
Subject: fix security group revoke

---
 nova/api/ec2/cloud.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 4cf2666a5..6eea95f84 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -295,7 +295,7 @@ class CloudController(object):
                     db.security_group_get_by_name(context,
                                                   source_project_id,
                                                   source_security_group_name)
-            values['group_id'] = source_security_group.id
+            values['group_id'] = source_security_group['id']
         elif cidr_ip:
             # If this fails, it throws an exception. This is what we want.
             IPy.IP(cidr_ip)
@@ -331,17 +331,19 @@ class CloudController(object):
                                                        group_name)
 
         criteria = self._authorize_revoke_rule_args_to_dict(context, **kwargs)
+        if criteria == None:
+            raise exception.ApiError("No rule for the specified parameters.")
 
         for rule in security_group.rules:
+            match = True
             for (k,v) in criteria.iteritems():
                 if getattr(rule, k, False) != v:
-                    break
-            # If we make it here, we have a match
-            db.security_group_rule_destroy(context, rule.id)
+                    match = False
+            if match:
+                db.security_group_rule_destroy(context, rule['id'])
+                self._trigger_refresh_security_group(security_group)
 
-        self._trigger_refresh_security_group(security_group)
-
-        return True
+        raise exception.ApiError("No rule for the specified parameters.")
 
     # TODO(soren): Dupe detection. Adding the same rule twice actually
     #              adds the same rule twice to the rule set, which is
-- 
cgit 


From 3124cf70c6ab2bcab570f0ffbcbe31672a9556f8 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Tue, 28 Sep 2010 21:03:45 -0700
Subject: fix join and misnamed method

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 6eea95f84..a1a3960f6 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -385,7 +385,7 @@ class CloudController(object):
 
 
     def create_security_group(self, context, group_name, group_description):
-        if db.securitygroup_exists(context, context.project.id, group_name):
+        if db.security_group_exists(context, context.project.id, group_name):
             raise exception.ApiError('group %s already exists' % group_name)
 
         group = {'user_id' : context.user.id,
-- 
cgit 


From 970114e1729c35ebcc05930659bb5dfaf5b59d3d Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Wed, 29 Sep 2010 00:30:35 -0700
Subject: fix loading to ignore deleted items

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 4c27440dc..d85b8512a 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -342,7 +342,7 @@ class CloudController(object):
             if match:
                 db.security_group_rule_destroy(context, rule['id'])
                 self._trigger_refresh_security_group(security_group)
-
+                return True
         raise exception.ApiError("No rule for the specified parameters.")
 
     # TODO(soren): Dupe detection. Adding the same rule twice actually
-- 
cgit 


From 4c1aa3d96f0c44d3e01864ca3128e9b052d1d7fd Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 29 Sep 2010 10:17:10 -0400
Subject: After update from trunk, a few more exceptions that need to be
 converted to Faults

---
 nova/api/rackspace/backup_schedules.py |  7 ++++---
 nova/api/rackspace/servers.py          | 17 +++++++++--------
 2 files changed, 13 insertions(+), 11 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/backup_schedules.py b/nova/api/rackspace/backup_schedules.py
index 46da778ee..cb83023bc 100644
--- a/nova/api/rackspace/backup_schedules.py
+++ b/nova/api/rackspace/backup_schedules.py
@@ -20,6 +20,7 @@ from webob import exc
 
 from nova import wsgi
 from nova.api.rackspace import _id_translator
+from nova.api.rackspace import faults
 import nova.image.service
 
 class Controller(wsgi.Controller):
@@ -27,12 +28,12 @@ class Controller(wsgi.Controller):
         pass
 
     def index(self, req, server_id):
-        return exc.HTTPNotFound()
+        return faults.Fault(exc.HTTPNotFound())
 
     def create(self, req, server_id):
         """ No actual update method required, since the existing API allows
         both create and update through a POST """
-        return exc.HTTPNotFound()
+        return faults.Fault(exc.HTTPNotFound())
 
     def delete(self, req, server_id):
-        return exc.HTTPNotFound()
+        return faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 4ab04bde7..888d67542 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -24,6 +24,7 @@ from nova import rpc
 from nova import utils
 from nova import wsgi
 from nova.api.rackspace import _id_translator
+from nova.api.rackspace import faults
 from nova.compute import power_state
 import nova.image.service
 
@@ -120,7 +121,7 @@ class Controller(wsgi.Controller):
         if inst:
             if inst.user_id == user_id:
                 return _entity_detail(inst)
-        raise exc.HTTPNotFound()
+        raise faults.Fault(exc.HTTPNotFound())
 
     def delete(self, req, id):
         """ Destroys a server """
@@ -128,13 +129,13 @@ class Controller(wsgi.Controller):
         instance = self.db_driver.instance_get(None, id)
         if instance and instance['user_id'] == user_id:
             self.db_driver.instance_destroy(None, id)
-            return exc.HTTPAccepted()
-        return exc.HTTPNotFound()
+            return faults.Fault(exc.HTTPAccepted())
+        return faults.Fault(exc.HTTPNotFound())
 
     def create(self, req):
         """ Creates a new server for a given user """
         if not req.environ.has_key('inst_dict'):
-            return exc.HTTPUnprocessableEntity()
+            return faults.Fault(exc.HTTPUnprocessableEntity())
 
         inst = self._build_server_instance(req)
 
@@ -147,22 +148,22 @@ class Controller(wsgi.Controller):
     def update(self, req, id):
         """ Updates the server name or password """
         if not req.environ.has_key('inst_dict'):
-            return exc.HTTPUnprocessableEntity()
+            return faults.Fault(exc.HTTPUnprocessableEntity())
 
         instance = self.db_driver.instance_get(None, id)
         if not instance:
-            return exc.HTTPNotFound()
+            return faults.Fault(exc.HTTPNotFound())
 
         attrs = req.environ['nova.context'].get('model_attributes', None)
         if attrs:
             self.db_driver.instance_update(None, id, _filter_params(attrs))
-        return exc.HTTPNoContent()
+        return faults.Fault(exc.HTTPNoContent())
 
     def action(self, req, id):
         """ multi-purpose method used to reboot, rebuild, and 
         resize a server """
         if not req.environ.has_key('inst_dict'):
-            return exc.HTTPUnprocessableEntity()
+            return faults.Fault(exc.HTTPUnprocessableEntity())
 
     def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
-- 
cgit 


From 29eca7e7992fc5c073d70f7c8ca5e5bc03f62af7 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 29 Sep 2010 11:37:26 -0400
Subject: Limit entity lists by &offset and &limit

---
 nova/api/rackspace/__init__.py | 20 ++++++++++++++++++++
 nova/api/rackspace/flavors.py  |  5 ++++-
 nova/api/rackspace/images.py   |  2 ++
 nova/api/rackspace/servers.py  | 18 ++++++++++++------
 4 files changed, 38 insertions(+), 7 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index 98802663f..48104f6df 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -165,3 +165,23 @@ class APIRouter(wsgi.Router):
                         controller=sharedipgroups.Controller())
 
         super(APIRouter, self).__init__(mapper)
+
+
+def limited(items, req):
+    """Return a slice of items according to requested offset and limit.
+    
+    items - a sliceable
+    req - wobob.Request possibly containing offset and limit GET variables.
+          offset is where to start in the list, and limit is the maximum number
+          of items to return.
+
+    If limit is not specified, 0, or > 1000, defaults to 1000.
+    """
+    offset = int(req.GET.get('offset', 0))
+    limit = int(req.GET.get('limit', 0))
+    if not limit:
+        limit = 1000
+    limit = min(1000, limit)
+    range_end = offset + limit
+    return items[offset:range_end]
+
diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
index 3bcf170e5..ba7aa937c 100644
--- a/nova/api/rackspace/flavors.py
+++ b/nova/api/rackspace/flavors.py
@@ -15,9 +15,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from webob import exc
+
 from nova.compute import instance_types
 from nova import wsgi
-from webob import exc
+import nova.api.rackspace
 
 class Controller(wsgi.Controller):
     """Flavor controller for the Rackspace API."""
@@ -38,6 +40,7 @@ class Controller(wsgi.Controller):
     def detail(self, req):
         """Return all flavors in detail."""
         items = [self.show(req, id)['flavor'] for id in self._all_ids()]
+        items = nova.api.rackspace.limited(items, req)
         return dict(flavors=items)
 
     def show(self, req, id):
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 11b058dec..7da17e6a7 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -19,6 +19,7 @@ from webob import exc
 
 from nova import wsgi
 from nova.api.rackspace import _id_translator
+import nova.api.rackspace
 import nova.image.service
 
 class Controller(wsgi.Controller):
@@ -45,6 +46,7 @@ class Controller(wsgi.Controller):
     def detail(self, req):
         """Return all public images in detail."""
         data = self._service.index()
+        data = nova.api.rackspace.limited(data, req)
         for img in data:
             img['id'] = self._id_translator.to_rs_id(img['id'])
         return dict(images=data)
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 4ab04bde7..958fc86a3 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -25,6 +25,7 @@ from nova import utils
 from nova import wsgi
 from nova.api.rackspace import _id_translator
 from nova.compute import power_state
+import nova.api.rackspace
 import nova.image.service
 
 FLAGS = flags.FLAGS
@@ -101,16 +102,21 @@ class Controller(wsgi.Controller):
 
     def index(self, req):
         """ Returns a list of server names and ids for a given user """
-        user_id = req.environ['nova.context']['user']['id']
-        instance_list = self.db_driver.instance_get_all_by_user(None, user_id)
-        res = [_entity_inst(inst)['server'] for inst in instance_list]
-        return _entity_list(res)
+        return self._items(req, entity_maker=_entity_inst)
 
     def detail(self, req):
         """ Returns a list of server details for a given user """
+        return self._items(req, entity_maker=_entity_detail)
+
+    def _items(self, req, entity_maker):
+        """Returns a list of servers for a given user.
+
+        entity_maker - either _entity_detail or _entity_inst
+        """
         user_id = req.environ['nova.context']['user']['id']
-        res = [_entity_detail(inst)['server'] for inst in 
-                self.db_driver.instance_get_all_by_user(None, user_id)]
+        instance_list = self.db_driver.instance_get_all_by_user(None, user_id)
+        limited_list = nova.api.rackspace.limited(instance_list, req)
+        res = [entity_maker(inst)['server'] for inst in limited_list]
         return _entity_list(res)
 
     def show(self, req, id):
-- 
cgit 


From 0868bcee453665b1ce24d43a90b3addfaab8c49d Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 12:16:53 -0500
Subject: Server update name and password

---
 nova/api/rackspace/servers.py | 61 +++++++++++++++++++++++++++----------------
 1 file changed, 38 insertions(+), 23 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 4ab04bde7..c156309bd 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import datetime
 import time
 
 from webob import exc
@@ -25,11 +26,13 @@ from nova import utils
 from nova import wsgi
 from nova.api.rackspace import _id_translator
 from nova.compute import power_state
+from nova.wsgi import Serializer
 import nova.image.service
 
 FLAGS = flags.FLAGS
 
-
+flags.DEFINE_string('rs_network_manager', 'nova.network.manager.FlatManager',
+    'Networking for rackspace')
 
 def translator_instance():
     """ Helper method for initializing the image id translator """
@@ -82,7 +85,6 @@ def _entity_inst(inst):
 
 class Controller(wsgi.Controller):
     """ The Server API controller for the Openstack API """
-    
 
     _serialization_metadata = {
         'application/xml': {
@@ -146,16 +148,19 @@ class Controller(wsgi.Controller):
 
     def update(self, req, id):
         """ Updates the server name or password """
-        if not req.environ.has_key('inst_dict'):
+        user_id = req.environ['nova.context']['user']['id']
+
+        inst_dict = self._deserialize(req.body, req)
+        
+        if not inst_dict:
             return exc.HTTPUnprocessableEntity()
 
         instance = self.db_driver.instance_get(None, id)
-        if not instance:
+        if not instance or instance.user_id != user_id:
             return exc.HTTPNotFound()
 
-        attrs = req.environ['nova.context'].get('model_attributes', None)
-        if attrs:
-            self.db_driver.instance_update(None, id, _filter_params(attrs))
+        self.db_driver.instance_update(None, id, 
+            _filter_params(inst_dict['server']))
         return exc.HTTPNoContent()
 
     def action(self, req, id):
@@ -170,34 +175,44 @@ class Controller(wsgi.Controller):
         inst = {}
 
         env = req.environ['inst_dict']
+        user_id = req.environ['nova.context']['user']['id']
 
+        inst['rs_id'] = _new_rs_id(user_id)
         image_id = env['server']['imageId']
+        
         opaque_id = translator_instance().from_rs_id(image_id)
 
-        inst['name'] = env['server']['server_name']
+        inst['name'] = env['server']['name']
         inst['image_id'] = opaque_id
         inst['instance_type'] = env['server']['flavorId']
-
-        user_id = req.environ['nova.context']['user']['id']
         inst['user_id'] = user_id
-
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
 
-        inst['project_id'] = env['project']['id']
-        inst['reservation_id'] = reservation
-        reservation = utils.generate_uid('r')
+        #TODO(dietz) These are the attributes I'm unsure of
+        inst['state_description'] = 'scheduling'
+        inst['kernel_id'] = ''
+        inst['ramdisk_id'] = ''
+        inst['reservation_id'] = utils.generate_uid('r')
+        inst['key_data'] = ''
+        inst['key_name'] = ''
+        inst['security_group'] = ''
+
+        # Flavor related attributes
+        inst['instance_type'] = ''
+        inst['memory_mb'] = ''
+        inst['vcpus'] = ''
+        inst['local_gb'] = ''
 
-        address = self.network.allocate_ip(
-                    inst['user_id'],
-                    inst['project_id'],
-                    mac=inst['mac_address'])
+        
+
+        #TODO(dietz): This seems necessary. How do these apply across
+        #the Rackspace implementation?
+        inst['project_id'] = ''
 
-        inst['private_dns_name'] = str(address)
-        inst['bridge_name'] = network.BridgedNetwork.get_network_for_project(
-                                inst['user_id'],
-                                inst['project_id'],
-                                'default')['bridge_name']
+        self.network_manager = utils.import_object(FLAGS.rs_network_manager)
+        
+        address = self.network_manager.allocate_fixed_ip( None, inst['id']) 
 
         ref = self.db_driver.instance_create(None, inst)
         inst['id'] = ref.id
-- 
cgit 


From 9c4319a83a6e7d61ffa6b78e9f17ea35821c5526 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 12:58:40 -0500
Subject: Make update work correctly

---
 nova/api/rackspace/servers.py | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index c156309bd..aa955c222 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -34,7 +34,12 @@ FLAGS = flags.FLAGS
 flags.DEFINE_string('rs_network_manager', 'nova.network.manager.FlatManager',
     'Networking for rackspace')
 
-def translator_instance():
+def _instance_id_translator():
+    """ Helper method for initializing an id translator for Rackspace instance
+    ids """
+    return _id_translator.RackspaceAPIIdTranslator( "instance", 'nova')
+
+def _image_id_translator():
     """ Helper method for initializing the image id translator """
     service = nova.image.service.ImageService.load()
     return _id_translator.RackspaceAPIIdTranslator(
@@ -42,11 +47,11 @@ def translator_instance():
 
 def _filter_params(inst_dict):
     """ Extracts all updatable parameters for a server update request """
-    keys = ['name', 'adminPass']
+    keys = dict(name='name', admin_pass='adminPass')
     new_attrs = {}
-    for k in keys:
-        if inst_dict.has_key(k):
-            new_attrs[k] = inst_dict[k]
+    for k, v in keys.items():
+        if inst_dict.has_key(v):
+            new_attrs[k] = inst_dict[v]
     return new_attrs
 
 def _entity_list(entities):
@@ -174,10 +179,13 @@ class Controller(wsgi.Controller):
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
         inst = {}
 
+        inst_id_trans = _instance_id_translator()
+        image_id_trans = _image_id_translator()
+
         env = req.environ['inst_dict']
         user_id = req.environ['nova.context']['user']['id']
 
-        inst['rs_id'] = _new_rs_id(user_id)
+        inst['rs_id'] = inst_id_trans.to_rs_id()
         image_id = env['server']['imageId']
         
         opaque_id = translator_instance().from_rs_id(image_id)
-- 
cgit 


From 2136f12d29cef9acc7dc6ee0a5901fa3878160f8 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 29 Sep 2010 15:09:39 -0400
Subject: Make Fault raiseable by inheriting from webob.exc.HTTPException.

Change from using self.exception which is reserved by HTTPException to self.wrapped_exc.
---
 nova/api/rackspace/faults.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/faults.py b/nova/api/rackspace/faults.py
index fd6bc3623..32e5c866f 100644
--- a/nova/api/rackspace/faults.py
+++ b/nova/api/rackspace/faults.py
@@ -17,11 +17,12 @@
 
 
 import webob.dec
+import webob.exc
 
 from nova import wsgi
 
 
-class Fault(wsgi.Application):
+class Fault(webob.exc.HTTPException):
 
     """An RS API fault response."""
 
@@ -39,23 +40,23 @@ class Fault(wsgi.Application):
 
     def __init__(self, exception):
         """Create a Fault for the given webob.exc.exception."""
-        self.exception = exception
+        self.wrapped_exc = exception
 
     @webob.dec.wsgify
     def __call__(self, req):
-        """Generate a WSGI response based on self.exception."""
+        """Generate a WSGI response based on the exception passed to ctor."""
         # Replace the body with fault details.
-        code = self.exception.status_int
+        code = self.wrapped_exc.status_int
         fault_name = self._fault_names.get(code, "cloudServersFault")
         fault_data = {
             fault_name: {
                 'code': code,
-                'message': self.exception.explanation}}
+                'message': self.wrapped_exc.explanation}}
         if code == 413:
-            retry = self.exception.headers['Retry-After']
+            retry = self.wrapped_exc.headers['Retry-After']
             fault_data[fault_name]['retryAfter'] = retry
         # 'code' is an attribute on the fault tag itself 
         metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
         serializer = wsgi.Serializer(req.environ, metadata)
-        self.exception.body = serializer.to_content_type(fault_data)
-        return self.exception
+        self.wrapped_exc.body = serializer.to_content_type(fault_data)
+        return self.wrapped_exc
-- 
cgit 


From 072661db01ed196eac92ceb1e942429a0e380e4a Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 29 Sep 2010 15:52:02 -0400
Subject: Support reboot in api.rackspace by extracting reboot function from
 api.ec2 into api.cloud.

---
 nova/api/cloud.py             | 42 ++++++++++++++++++++++++++++++++++++++++++
 nova/api/ec2/cloud.py         |  8 ++------
 nova/api/rackspace/servers.py | 10 ++++++++--
 3 files changed, 52 insertions(+), 8 deletions(-)
 create mode 100644 nova/api/cloud.py

(limited to 'nova/api')

diff --git a/nova/api/cloud.py b/nova/api/cloud.py
new file mode 100644
index 000000000..345677d4f
--- /dev/null
+++ b/nova/api/cloud.py
@@ -0,0 +1,42 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Methods for API calls to control instances via AMQP.
+"""
+
+
+from nova import db
+from nova import flags
+from nova import rpc
+
+FLAGS = flags.FLAGS
+
+
+def reboot(instance_id, context=None):
+    """Reboot the given instance.
+    
+    #TODO(gundlach) not actually sure what context is used for by ec2 here
+    -- I think we can just remove it and use None all the time.
+    """
+    instance_ref = db.instance_get_by_ec2_id(None, instance_id)
+    host = instance_ref['host']
+    rpc.cast(db.queue_get_for(context, FLAGS.compute_topic, host),
+             {"method": "reboot_instance",
+              "args": {"context": None,
+                       "instance_id": instance_ref['id']}})
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 05e8065f3..4d962fcdd 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -36,6 +36,7 @@ from nova import quota
 from nova import rpc
 from nova import utils
 from nova.compute.instance_types import INSTANCE_TYPES
+from nova.api import cloud
 from nova.api.ec2 import images
 
 
@@ -664,12 +665,7 @@ class CloudController(object):
     def reboot_instances(self, context, instance_id, **kwargs):
         """instance_id is a list of instance ids"""
         for id_str in instance_id:
-            instance_ref = db.instance_get_by_ec2_id(context, id_str)
-            host = instance_ref['host']
-            rpc.cast(db.queue_get_for(context, FLAGS.compute_topic, host),
-                     {"method": "reboot_instance",
-                      "args": {"context": None,
-                               "instance_id": instance_ref['id']}})
+            cloud.reboot(id_str, context=context)
         return True
 
     def delete_volume(self, context, volume_id, **kwargs):
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index aa955c222..4f81e25f9 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -24,6 +24,7 @@ from nova import flags
 from nova import rpc
 from nova import utils
 from nova import wsgi
+from nova.api import cloud
 from nova.api.rackspace import _id_translator
 from nova.compute import power_state
 from nova.wsgi import Serializer
@@ -171,8 +172,13 @@ class Controller(wsgi.Controller):
     def action(self, req, id):
         """ multi-purpose method used to reboot, rebuild, and 
         resize a server """
-        if not req.environ.has_key('inst_dict'):
-            return exc.HTTPUnprocessableEntity()
+        input_dict = self._deserialize(req.body, req)
+        try:
+            reboot_type = input_dict['reboot']['type']
+        except Exception:
+            raise faults.Fault(webob.exc.HTTPNotImplemented())
+        opaque_id = _instance_id_translator().from_rsapi_id(id)
+        cloud.reboot(opaque_id)
 
     def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
-- 
cgit 


From 128ec65cf39e74b53903dd9788a58c8eb513abe8 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 16:21:28 -0500
Subject: Server creation up to, but not including, network configuration

---
 nova/api/rackspace/servers.py | 97 +++++++++++++++++++++++++++----------------
 1 file changed, 62 insertions(+), 35 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index aa955c222..cc971adc0 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -25,6 +25,7 @@ from nova import rpc
 from nova import utils
 from nova import wsgi
 from nova.api.rackspace import _id_translator
+from nova.compute import instance_types
 from nova.compute import power_state
 from nova.wsgi import Serializer
 import nova.image.service
@@ -39,11 +40,11 @@ def _instance_id_translator():
     ids """
     return _id_translator.RackspaceAPIIdTranslator( "instance", 'nova')
 
-def _image_id_translator():
+def _image_service():
     """ Helper method for initializing the image id translator """
     service = nova.image.service.ImageService.load()
-    return _id_translator.RackspaceAPIIdTranslator(
-            "image", service.__class__.__name__)
+    return (service, _id_translator.RackspaceAPIIdTranslator(
+            "image", service.__class__.__name__))
 
 def _filter_params(inst_dict):
     """ Extracts all updatable parameters for a server update request """
@@ -122,8 +123,11 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """ Returns server details by server id """
+        inst_id_trans = _instance_id_translator()
+        inst_id = inst_id_trans.from_rs_id(id)
+
         user_id = req.environ['nova.context']['user']['id']
-        inst = self.db_driver.instance_get(None, id)
+        inst = self.db_driver.instance_get_by_ec2_id(None, inst_id)
         if inst:
             if inst.user_id == user_id:
                 return _entity_detail(inst)
@@ -131,8 +135,11 @@ class Controller(wsgi.Controller):
 
     def delete(self, req, id):
         """ Destroys a server """
+        inst_id_trans = _instance_id_translator()
+        inst_id = inst_id_trans.from_rs_id(id)
+
         user_id = req.environ['nova.context']['user']['id']
-        instance = self.db_driver.instance_get(None, id)
+        instance = self.db_driver.instance_get_by_ec2_id(None, inst_id)
         if instance and instance['user_id'] == user_id:
             self.db_driver.instance_destroy(None, id)
             return exc.HTTPAccepted()
@@ -140,10 +147,16 @@ class Controller(wsgi.Controller):
 
     def create(self, req):
         """ Creates a new server for a given user """
-        if not req.environ.has_key('inst_dict'):
+
+        env = self._deserialize(req.body, req)
+        if not env:
             return exc.HTTPUnprocessableEntity()
 
-        inst = self._build_server_instance(req)
+        #try:
+        inst = self._build_server_instance(req, env)
+        #except Exception, e:
+        #    print e
+        #    return exc.HTTPUnprocessableEntity()
 
         rpc.cast(
             FLAGS.compute_topic, {
@@ -153,6 +166,8 @@ class Controller(wsgi.Controller):
 
     def update(self, req, id):
         """ Updates the server name or password """
+        inst_id_trans = _instance_id_translator()
+        inst_id = inst_id_trans.from_rs_id(id)
         user_id = req.environ['nova.context']['user']['id']
 
         inst_dict = self._deserialize(req.body, req)
@@ -160,7 +175,7 @@ class Controller(wsgi.Controller):
         if not inst_dict:
             return exc.HTTPUnprocessableEntity()
 
-        instance = self.db_driver.instance_get(None, id)
+        instance = self.db_driver.instance_get_by_ec2_id(None, inst_id)
         if not instance or instance.user_id != user_id:
             return exc.HTTPNotFound()
 
@@ -174,56 +189,68 @@ class Controller(wsgi.Controller):
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
-    def _build_server_instance(self, req):
+    def _build_server_instance(self, req, env):
         """Build instance data structure and save it to the data store."""
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
         inst = {}
 
         inst_id_trans = _instance_id_translator()
-        image_id_trans = _image_id_translator()
 
-        env = req.environ['inst_dict']
         user_id = req.environ['nova.context']['user']['id']
 
-        inst['rs_id'] = inst_id_trans.to_rs_id()
+        instance_type, flavor = None, None
+        for k, v in instance_types.INSTANCE_TYPES.iteritems():
+            if v['flavorid'] == env['server']['flavorId']:
+                instance_type, flavor = k, v
+                break
+
+        if not flavor:
+            raise Exception, "Flavor not found"
+
         image_id = env['server']['imageId']
         
-        opaque_id = translator_instance().from_rs_id(image_id)
+        img_service, image_id_trans = _image_service()
+
+        opaque_image_id = image_id_trans.to_rs_id(image_id)        
+        image = img_service.show(opaque_image_id)
 
-        inst['name'] = env['server']['name']
-        inst['image_id'] = opaque_id
-        inst['instance_type'] = env['server']['flavorId']
+        if not image: 
+            raise Exception, "Image not found"
+
+        inst['server_name'] = env['server']['name']
+        inst['image_id'] = opaque_image_id
         inst['user_id'] = user_id
         inst['launch_time'] = ltime
         inst['mac_address'] = utils.generate_mac()
+        inst['project_id'] = user_id
 
-        #TODO(dietz) These are the attributes I'm unsure of
         inst['state_description'] = 'scheduling'
-        inst['kernel_id'] = ''
-        inst['ramdisk_id'] = ''
+        inst['kernel_id'] = image.get('kernelId', FLAGS.default_kernel)
+        inst['ramdisk_id'] = image.get('ramdiskId', FLAGS.default_ramdisk)
         inst['reservation_id'] = utils.generate_uid('r')
-        inst['key_data'] = ''
-        inst['key_name'] = ''
-        inst['security_group'] = ''
 
-        # Flavor related attributes
-        inst['instance_type'] = ''
-        inst['memory_mb'] = ''
-        inst['vcpus'] = ''
-        inst['local_gb'] = ''
+        #TODO(dietz) this may be ill advised
+        key_pair_ref = self.db_driver.key_pair_get_all_by_user(
+            None, user_id)[0]
 
-        
+        inst['key_data'] = key_pair_ref['public_key']
+        inst['key_name'] = key_pair_ref['name']
 
-        #TODO(dietz): This seems necessary. How do these apply across
-        #the Rackspace implementation?
-        inst['project_id'] = ''
+        #TODO(dietz) stolen from ec2 api, see TODO there
+        inst['security_group'] = 'default'
 
-        self.network_manager = utils.import_object(FLAGS.rs_network_manager)
-        
-        address = self.network_manager.allocate_fixed_ip( None, inst['id']) 
+        # Flavor related attributes
+        inst['instance_type'] = instance_type
+        inst['memory_mb'] = flavor['memory_mb']
+        inst['vcpus'] = flavor['vcpus']
+        inst['local_gb'] = flavor['local_gb']
 
         ref = self.db_driver.instance_create(None, inst)
-        inst['id'] = ref.id
+        inst['id'] = inst_id_trans.to_rs_id(ref.ec2_id)
+
+        #self.network_manager = utils.import_object(FLAGS.rs_network_manager)
+        #
+        #address = self.network_manager.allocate_fixed_ip( None, inst['id']) 
         
         return inst
 
-- 
cgit 


From 35741ff23bec2b4f301b93128fd018e9c8e70945 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 17:06:35 -0500
Subject: Servers stuff

---
 nova/api/rackspace/servers.py | 38 ++++++++++++++++++++++++++++++++++----
 1 file changed, 34 insertions(+), 4 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 357e0895f..40cd4f691 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -26,6 +26,8 @@ from nova import utils
 from nova import wsgi
 from nova.api import cloud
 from nova.api.rackspace import _id_translator
+from nova.api.rackspace import context
+from nova.api.rackspace import faults
 from nova.compute import instance_types
 from nova.compute import power_state
 from nova.wsgi import Serializer
@@ -254,10 +256,38 @@ class Controller(wsgi.Controller):
         ref = self.db_driver.instance_create(None, inst)
         inst['id'] = inst_id_trans.to_rs_id(ref.ec2_id)
 
-        #self.network_manager = utils.import_object(FLAGS.rs_network_manager)
-        #
-        #address = self.network_manager.allocate_fixed_ip( None, inst['id']) 
         
+        # TODO(dietz): this isn't explicitly necessary, but the networking
+        # calls depend on an object with a project_id property
+        context = context.APIRequestContext(user_id)
+    
+        inst['mac_address'] = utils.generate_mac()
+        
+        #TODO(dietz) is this necessary? 
+        inst['launch_index'] = 0
+
+        inst['hostname'] = instance_ref['ec2_id']
+        self.db_driver.instance_update(None, inst_id, inst)
+        self.network_manager = utils.import_object(FLAGS.rs_network_manager)
+        address = self.network_manager.allocate_fixed_ip(context, inst_id)
+
+        # TODO(vish): This probably should be done in the scheduler
+        #             network is setup when host is assigned
+        network_topic = self._get_network_topic(user_id)
+        rpc.call(network_topic,
+                 {"method": "setup_fixed_ip",
+                  "args": {"context": None,
+                           "address": address}})
         return inst
 
-    
+    def _get_network_topic(self, user_id):
+        """Retrieves the network host for a project"""
+        network_ref = self.db_driver.project_get_network(None, 
+            user_id)
+        host = network_ref['host']
+        if not host:
+            host = rpc.call(FLAGS.network_topic,
+                                  {"method": "set_network_host",
+                                   "args": {"context": None,
+                                            "project_id": user_id}})
+        return self.db_driver.queue_get_for(None, FLAGS.network_topic, host)
-- 
cgit 


From 33f101c309852f358ab30a8af64ef64a848f16ae Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 17:36:26 -0500
Subject: Some minor cleanup

---
 nova/api/rackspace/servers.py | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index c3d56debd..0d285999b 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -213,14 +213,11 @@ class Controller(wsgi.Controller):
 
         user_id = req.environ['nova.context']['user']['id']
 
-        instance_type, flavor = None, None
-        for k, v in instance_types.INSTANCE_TYPES.iteritems():
-            if v['flavorid'] == env['server']['flavorId']:
-                instance_type, flavor = k, v
-                break
+        flavor_id = env['server']['flavorId']
 
-        if not flavor:
-            raise Exception, "Flavor not found"
+        instance_type, flavor = [(k, v) for k, v in
+            instance_types.INSTANCE_TYPES.iteritems()
+            if v['flavorid'] == flavor_id][0]
 
         image_id = env['server']['imageId']
         
@@ -262,10 +259,10 @@ class Controller(wsgi.Controller):
 
         ref = self.db_driver.instance_create(None, inst)
         inst['id'] = inst_id_trans.to_rs_id(ref.ec2_id)
-
         
         # TODO(dietz): this isn't explicitly necessary, but the networking
-        # calls depend on an object with a project_id property
+        # calls depend on an object with a project_id property, and therefore
+        # should be cleaned up later
         api_context = context.APIRequestContext(user_id)
     
         inst['mac_address'] = utils.generate_mac()
-- 
cgit 


From 41e940a5cfa62d56e7d4f111827217c64f0ec61d Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 17:40:46 -0500
Subject: Forgot the context module

---
 nova/api/rackspace/context.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 nova/api/rackspace/context.py

(limited to 'nova/api')

diff --git a/nova/api/rackspace/context.py b/nova/api/rackspace/context.py
new file mode 100644
index 000000000..3a7941f0f
--- /dev/null
+++ b/nova/api/rackspace/context.py
@@ -0,0 +1,32 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequestContext
+"""
+
+import random
+
+class APIRequestContext(object):
+    """ This is an adapter class to get around all of the assumptions made in
+    the FlatNetworking """
+    def __init__(self, user_id):
+        class Dummy(object): pass
+        self.user_id = user_id
+        self.project = Dummy()
+        self.project.id = self.user_id
-- 
cgit 


From 6b932780b6bf10b387ad04be6ec88395cae6b564 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 17:52:15 -0500
Subject: pylint and pep8 cleanup

---
 nova/api/rackspace/context.py | 8 +++++---
 nova/api/rackspace/servers.py | 8 +++-----
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/context.py b/nova/api/rackspace/context.py
index 3a7941f0f..924ee151e 100644
--- a/nova/api/rackspace/context.py
+++ b/nova/api/rackspace/context.py
@@ -22,11 +22,13 @@ APIRequestContext
 
 import random
 
+class Project(object):
+    def __init__(self, user_id):
+        self.id = user_id
+    
 class APIRequestContext(object):
     """ This is an adapter class to get around all of the assumptions made in
     the FlatNetworking """
     def __init__(self, user_id):
-        class Dummy(object): pass
         self.user_id = user_id
-        self.project = Dummy()
-        self.project.id = self.user_id
+        self.project = Project(user_id)
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 0d285999b..965deb402 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -15,7 +15,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import datetime
 import time
 
 import webob
@@ -31,7 +30,6 @@ from nova.api.rackspace import context
 from nova.api.rackspace import faults
 from nova.compute import instance_types
 from nova.compute import power_state
-from nova.wsgi import Serializer
 import nova.api.rackspace
 import nova.image.service
 
@@ -201,7 +199,7 @@ class Controller(wsgi.Controller):
             reboot_type = input_dict['reboot']['type']
         except Exception:
             raise faults.Fault(webob.exc.HTTPNotImplemented())
-        opaque_id = _instance_id_translator().from_rsapi_id(id)
+        opaque_id = _instance_id_translator().from_rs_id(id)
         cloud.reboot(opaque_id)
 
     def _build_server_instance(self, req, env):
@@ -273,8 +271,8 @@ class Controller(wsgi.Controller):
         inst['hostname'] = ref.ec2_id
         self.db_driver.instance_update(None, inst['id'], inst)
 
-        self.network_manager = utils.import_object(FLAGS.rs_network_manager)
-        address = self.network_manager.allocate_fixed_ip(api_context,
+        network_manager = utils.import_object(FLAGS.rs_network_manager)
+        address = network_manager.allocate_fixed_ip(api_context,
             inst['id'])
 
         # TODO(vish): This probably should be done in the scheduler
-- 
cgit 


From 13a73f2606f4b9dee4e51cccbb7e48c8ce322b76 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 18:00:24 -0500
Subject: Missed a few attributes while mirroring the ec2 instance spin up

---
 nova/api/rackspace/servers.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 965deb402..2395cb358 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -239,6 +239,9 @@ class Controller(wsgi.Controller):
         inst['ramdisk_id'] = image.get('ramdiskId', FLAGS.default_ramdisk)
         inst['reservation_id'] = utils.generate_uid('r')
 
+        inst['display_name'] = env['server']['name']
+        inst['display_description'] = env['server']['name']
+
         #TODO(dietz) this may be ill advised
         key_pair_ref = self.db_driver.key_pair_get_all_by_user(
             None, user_id)[0]
-- 
cgit 


From b075b504a0a402fc4e8c24379804633139883008 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 29 Sep 2010 19:28:14 -0500
Subject: Whoops, forgot the exception handling bit

---
 nova/api/rackspace/servers.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 2395cb358..11efd8aef 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -160,11 +160,10 @@ class Controller(wsgi.Controller):
         if not env:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
-        #try:
-        inst = self._build_server_instance(req, env)
-        #except Exception, e:
-        #    print e
-        #    return exc.HTTPUnprocessableEntity()
+        try:
+            inst = self._build_server_instance(req, env)
+        except Exception, e:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
 
         rpc.cast(
             FLAGS.compute_topic, {
-- 
cgit 


From cf456bdb2a767644d95599aa1c8f580279959a4e Mon Sep 17 00:00:00 2001
From: Devin Carlen <devin.carlen@gmail.com>
Date: Thu, 30 Sep 2010 02:47:05 -0700
Subject: Refactored APIRequestContext

---
 nova/api/context.py      | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 nova/api/ec2/__init__.py |  8 ++++----
 nova/api/ec2/context.py  | 33 ---------------------------------
 3 files changed, 50 insertions(+), 37 deletions(-)
 create mode 100644 nova/api/context.py
 delete mode 100644 nova/api/ec2/context.py

(limited to 'nova/api')

diff --git a/nova/api/context.py b/nova/api/context.py
new file mode 100644
index 000000000..b66cfe468
--- /dev/null
+++ b/nova/api/context.py
@@ -0,0 +1,46 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequestContext
+"""
+
+import random
+
+
+class APIRequestContext(object):
+    def __init__(self, user, project):
+        self.user = user
+        self.project = project
+        self.request_id = ''.join(
+                [random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-')
+                 for x in xrange(20)]
+                )
+        if user:
+            self.is_admin = user.is_admin()
+        else:
+            self.is_admin = False
+        self.read_deleted = False
+
+
+def get_admin_context(user=None, read_deleted=False):
+    context_ref = APIRequestContext(user=user, project=None)
+    context_ref.is_admin = True
+    context_ref.read_deleted = read_deleted
+    return context_ref
+
diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 7a958f841..6b538a7f1 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -27,8 +27,8 @@ import webob.exc
 from nova import exception
 from nova import flags
 from nova import wsgi
+from nova.api import context
 from nova.api.ec2 import apirequest
-from nova.api.ec2 import context
 from nova.api.ec2 import admin
 from nova.api.ec2 import cloud
 from nova.auth import manager
@@ -193,15 +193,15 @@ class Authorizer(wsgi.Middleware):
             return True
         if 'none' in roles:
             return False
-        return any(context.project.has_role(context.user.id, role) 
+        return any(context.project.has_role(context.user.id, role)
                    for role in roles)
-    
+
 
 class Executor(wsgi.Application):
 
     """Execute an EC2 API request.
 
-    Executes 'ec2.action' upon 'ec2.controller', passing 'ec2.context' and 
+    Executes 'ec2.action' upon 'ec2.controller', passing 'ec2.context' and
     'ec2.action_args' (all variables in WSGI environ.)  Returns an XML
     response, or a 400 upon failure.
     """
diff --git a/nova/api/ec2/context.py b/nova/api/ec2/context.py
deleted file mode 100644
index c53ba98d9..000000000
--- a/nova/api/ec2/context.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-APIRequestContext
-"""
-
-import random
-
-
-class APIRequestContext(object):
-    def __init__(self, user, project):
-        self.user = user
-        self.project = project
-        self.request_id = ''.join(
-                [random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-')
-                 for x in xrange(20)]
-                )
-- 
cgit 


From 75c5ba6aae6a57a61771ed78b6797c90f7da6940 Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 30 Sep 2010 09:22:46 -0500
Subject: Grabbed the wrong copyright info

---
 nova/api/rackspace/context.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/context.py b/nova/api/rackspace/context.py
index 924ee151e..77394615b 100644
--- a/nova/api/rackspace/context.py
+++ b/nova/api/rackspace/context.py
@@ -1,7 +1,6 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
+# Copyright 2010 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
-- 
cgit 


From 58ae192764b11b19f5676f9496f287a4ea2a71bd Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 30 Sep 2010 20:07:26 -0500
Subject: refactoring

---
 nova/api/cloud.py             |  2 +-
 nova/api/rackspace/servers.py | 25 ++++++-------------------
 2 files changed, 7 insertions(+), 20 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/cloud.py b/nova/api/cloud.py
index 345677d4f..57e94a17a 100644
--- a/nova/api/cloud.py
+++ b/nova/api/cloud.py
@@ -34,7 +34,7 @@ def reboot(instance_id, context=None):
     #TODO(gundlach) not actually sure what context is used for by ec2 here
     -- I think we can just remove it and use None all the time.
     """
-    instance_ref = db.instance_get_by_ec2_id(None, instance_id)
+    instance_ref = db.instance_get_by_internal_id(None, instance_id)
     host = instance_ref['host']
     rpc.cast(db.queue_get_for(context, FLAGS.compute_topic, host),
              {"method": "reboot_instance",
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 11efd8aef..39e784be2 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -35,9 +35,6 @@ import nova.image.service
 
 FLAGS = flags.FLAGS
 
-flags.DEFINE_string('rs_network_manager', 'nova.network.manager.FlatManager',
-    'Networking for rackspace')
-
 def _instance_id_translator():
     """ Helper method for initializing an id translator for Rackspace instance
     ids """
@@ -131,11 +128,8 @@ class Controller(wsgi.Controller):
 
     def show(self, req, id):
         """ Returns server details by server id """
-        inst_id_trans = _instance_id_translator()
-        inst_id = inst_id_trans.from_rs_id(id)
-
         user_id = req.environ['nova.context']['user']['id']
-        inst = self.db_driver.instance_get_by_ec2_id(None, inst_id)
+        inst = self.db_driver.instance_get_by_instance_id(None, id)
         if inst:
             if inst.user_id == user_id:
                 return _entity_detail(inst)
@@ -143,11 +137,8 @@ class Controller(wsgi.Controller):
 
     def delete(self, req, id):
         """ Destroys a server """
-        inst_id_trans = _instance_id_translator()
-        inst_id = inst_id_trans.from_rs_id(id)
-
         user_id = req.environ['nova.context']['user']['id']
-        instance = self.db_driver.instance_get_by_ec2_id(None, inst_id)
+        instance = self.db_driver.instance_get_by_internal_id(None, id)
         if instance and instance['user_id'] == user_id:
             self.db_driver.instance_destroy(None, id)
             return faults.Fault(exc.HTTPAccepted())
@@ -173,8 +164,6 @@ class Controller(wsgi.Controller):
 
     def update(self, req, id):
         """ Updates the server name or password """
-        inst_id_trans = _instance_id_translator()
-        inst_id = inst_id_trans.from_rs_id(id)
         user_id = req.environ['nova.context']['user']['id']
 
         inst_dict = self._deserialize(req.body, req)
@@ -182,7 +171,7 @@ class Controller(wsgi.Controller):
         if not inst_dict:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
-        instance = self.db_driver.instance_get_by_ec2_id(None, inst_id)
+        instance = self.db_driver.instance_get_by_internal_id(None, id)
         if not instance or instance.user_id != user_id:
             return faults.Fault(exc.HTTPNotFound())
 
@@ -206,8 +195,6 @@ class Controller(wsgi.Controller):
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
         inst = {}
 
-        inst_id_trans = _instance_id_translator()
-
         user_id = req.environ['nova.context']['user']['id']
 
         flavor_id = env['server']['flavorId']
@@ -258,7 +245,7 @@ class Controller(wsgi.Controller):
         inst['local_gb'] = flavor['local_gb']
 
         ref = self.db_driver.instance_create(None, inst)
-        inst['id'] = inst_id_trans.to_rs_id(ref.ec2_id)
+        inst['id'] = ref.internal_id
         
         # TODO(dietz): this isn't explicitly necessary, but the networking
         # calls depend on an object with a project_id property, and therefore
@@ -270,10 +257,10 @@ class Controller(wsgi.Controller):
         #TODO(dietz) is this necessary? 
         inst['launch_index'] = 0
 
-        inst['hostname'] = ref.ec2_id
+        inst['hostname'] = ref.internal_id
         self.db_driver.instance_update(None, inst['id'], inst)
 
-        network_manager = utils.import_object(FLAGS.rs_network_manager)
+        network_manager = utils.import_object(FLAGS.network_manager)
         address = network_manager.allocate_fixed_ip(api_context,
             inst['id'])
 
-- 
cgit 


From 58773e16ddd6f3aaa4aafefde55a3ae631e806dd Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Thu, 30 Sep 2010 21:59:52 -0400
Subject: Convert EC2 cloud.py from assuming that EC2 IDs are stored directly
 in the database, to assuming that EC2 IDs should be converted to internal
 IDs.

The conversion between the internal ID and the EC2 ID is imperfect -- right now it turns internal IDs like 408 into EC2 IDs like i-408, and vice versa.  Instead, EC2 IDs are supposed to be i-[base 36 of the integer].
---
 nova/api/ec2/cloud.py | 58 ++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 41 insertions(+), 17 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 79c95788b..2fec49da8 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -113,6 +113,16 @@ class CloudController(object):
                     result[key] = [line]
         return result
 
+    def ec2_id_to_internal_id(ec2_id):
+        """Convert an ec2 ID (i-[base 36 number]) to an internal id (int)"""
+        # TODO(gundlach): Maybe this should actually work?
+        return ec2_id[2:]
+
+    def internal_id_to_ec2_id(internal_id):
+        """Convert an internal ID (int) to an ec2 ID (i-[base 36 number])"""
+        # TODO(gundlach): Yo maybe this should actually convert to base 36
+        return "i-%d" % internal_id
+
     def get_metadata(self, address):
         instance_ref = db.fixed_ip_get_instance(None, address)
         if instance_ref is None:
@@ -144,7 +154,7 @@ class CloudController(object):
                 },
                 'hostname': hostname,
                 'instance-action': 'none',
-                'instance-id': instance_ref['ec2_id'],
+                'instance-id': internal_id_to_ec2_id(instance_ref['internal_id']),
                 'instance-type': instance_ref['instance_type'],
                 'local-hostname': hostname,
                 'local-ipv4': address,
@@ -244,9 +254,11 @@ class CloudController(object):
     def delete_security_group(self, context, group_name, **kwargs):
         return True
 
-    def get_console_output(self, context, instance_id, **kwargs):
-        # instance_id is passed in as a list of instances
-        instance_ref = db.instance_get_by_ec2_id(context, instance_id[0])
+    def get_console_output(self, context, ec2_id_list, **kwargs):
+        # ec2_id_list is passed in as a list of instances
+        ec2_id = ec2_id_list[0]
+        internal_id = ec2_id_to_internal_id(ec2_id)
+        instance_ref = db.instance_get_by_ec2_id(context, internal_id)
         return rpc.call('%s.%s' % (FLAGS.compute_topic,
                                    instance_ref['host']),
                         {"method": "get_console_output",
@@ -326,7 +338,8 @@ class CloudController(object):
             raise exception.ApiError("Volume status must be available")
         if volume_ref['attach_status'] == "attached":
             raise exception.ApiError("Volume is already attached")
-        instance_ref = db.instance_get_by_ec2_id(context, instance_id)
+        internal_id = ec2_id_to_internal_id(instance_id)
+        instance_ref = db.instance_get_by_internal_id(context, internal_id)
         host = instance_ref['host']
         rpc.cast(db.queue_get_for(context, FLAGS.compute_topic, host),
                                 {"method": "attach_volume",
@@ -360,9 +373,11 @@ class CloudController(object):
             # If the instance doesn't exist anymore,
             # then we need to call detach blind
             db.volume_detached(context)
+        internal_id = instance_ref['internal_id']
+        ec2_id = internal_id_to_ec2_id(internal_id)
         return {'attachTime': volume_ref['attach_time'],
                 'device': volume_ref['mountpoint'],
-                'instanceId': instance_ref['ec2_id'],
+                'instanceId': internal_id,
                 'requestId': context.request_id,
                 'status': volume_ref['attach_status'],
                 'volumeId': volume_ref['id']}
@@ -411,7 +426,9 @@ class CloudController(object):
                 if instance['image_id'] == FLAGS.vpn_image_id:
                     continue
             i = {}
-            i['instanceId'] = instance['ec2_id']
+            internal_id = instance['internal_id']
+            ec2_id = internal_id_to_ec2_id(internal_id)
+            i['instanceId'] = ec2_id
             i['imageId'] = instance['image_id']
             i['instanceState'] = {
                 'code': instance['state'],
@@ -464,9 +481,10 @@ class CloudController(object):
             instance_id = None
             if (floating_ip_ref['fixed_ip']
                 and floating_ip_ref['fixed_ip']['instance']):
-                instance_id = floating_ip_ref['fixed_ip']['instance']['ec2_id']
+                internal_id = floating_ip_ref['fixed_ip']['instance']['ec2_id']
+                ec2_id = internal_id_to_ec2_id(internal_id)
             address_rv = {'public_ip': address,
-                          'instance_id': instance_id}
+                          'instance_id': ec2_id}
             if context.user.is_admin():
                 details = "%s (%s)" % (address_rv['instance_id'],
                                        floating_ip_ref['project_id'])
@@ -498,8 +516,9 @@ class CloudController(object):
                            "floating_address": floating_ip_ref['address']}})
         return {'releaseResponse': ["Address released."]}
 
-    def associate_address(self, context, instance_id, public_ip, **kwargs):
-        instance_ref = db.instance_get_by_ec2_id(context, instance_id)
+    def associate_address(self, context, ec2_id, public_ip, **kwargs):
+        internal_id = ec2_id_to_internal_id(ec2_id)
+        instance_ref = db.instance_get_by_internal_id(context, internal_id)
         fixed_address = db.instance_get_fixed_address(context,
                                                       instance_ref['id'])
         floating_ip_ref = db.floating_ip_get_by_address(context, public_ip)
@@ -610,7 +629,9 @@ class CloudController(object):
             inst = {}
             inst['mac_address'] = utils.generate_mac()
             inst['launch_index'] = num
-            inst['hostname'] = instance_ref['ec2_id']
+            internal_id = instance_ref['internal_id']
+            ec2_id = internal_id_to_ec2_id(internal_id)
+            inst['hostname'] = ec2_id
             db.instance_update(context, inst_id, inst)
             address = self.network_manager.allocate_fixed_ip(context,
                                                              inst_id,
@@ -634,12 +655,14 @@ class CloudController(object):
         return self._format_run_instances(context, reservation_id)
 
 
-    def terminate_instances(self, context, instance_id, **kwargs):
+    def terminate_instances(self, context, ec2_id_list, **kwargs):
         logging.debug("Going to start terminating instances")
-        for id_str in instance_id:
+        for id_str in ec2_id_list:
+            internal_id = ec2_id_to_internal_id(id_str)
             logging.debug("Going to try and terminate %s" % id_str)
             try:
-                instance_ref = db.instance_get_by_ec2_id(context, id_str)
+                instance_ref = db.instance_get_by_internal_id(context, 
+                                                              internal_id)
             except exception.NotFound:
                 logging.warning("Instance %s was not found during terminate"
                                 % id_str)
@@ -688,7 +711,7 @@ class CloudController(object):
             cloud.reboot(id_str, context=context)
         return True
 
-    def update_instance(self, context, instance_id, **kwargs):
+    def update_instance(self, context, ec2_id, **kwargs):
         updatable_fields = ['display_name', 'display_description']
         changes = {}
         for field in updatable_fields:
@@ -696,7 +719,8 @@ class CloudController(object):
                 changes[field] = kwargs[field]
         if changes:
             db_context = {}
-            inst = db.instance_get_by_ec2_id(db_context, instance_id)
+            internal_id = ec2_id_to_internal_id(ec2_id)
+            inst = db.instance_get_by_internal_id(db_context, internal_id)
             db.instance_update(db_context, inst['id'], kwargs)
         return True
 
-- 
cgit 


From ddaaebb28649811d723f93a89ee46d69cc3ecabc Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Thu, 30 Sep 2010 20:24:42 -0700
Subject: show project ids for groups instead of user ids

---
 nova/api/ec2/cloud.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 6c67db28d..8aa76a787 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -260,7 +260,7 @@ class CloudController(object):
         g = {}
         g['groupDescription'] = group.description
         g['groupName'] = group.name
-        g['ownerId'] = context.user.id
+        g['ownerId'] = group.project_id
         g['ipPermissions'] = []
         for rule in group.rules:
             r = {}
@@ -272,7 +272,7 @@ class CloudController(object):
             if rule.group_id:
                 source_group = db.security_group_get(context, rule.group_id)
                 r['groups'] += [{'groupName': source_group.name,
-                                 'userId': source_group.user_id}]
+                                 'userId': source_group.project_id}]
             else:
                 r['ipRanges'] += [{'cidrIp': rule.cidr}]
             g['ipPermissions'] += [r]
-- 
cgit 


From c9d2b8bcb365f326a47df93920c11be2ca054b18 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@yahoo.com>
Date: Thu, 30 Sep 2010 23:04:53 -0700
Subject: Fixed flat network manager with network index gone.

Both managers use ips created through nova manage.

Use of project_get_network is minimized to make way for managers that
would prefer to use cluste or host based ips instead of project based ips.
---
 nova/api/ec2/cloud.py         | 11 ++++++-----
 nova/api/rackspace/servers.py | 37 ++++++++++++++++++-------------------
 2 files changed, 24 insertions(+), 24 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 79c95788b..d8462f7a0 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -522,13 +522,13 @@ class CloudController(object):
 
     def _get_network_topic(self, context):
         """Retrieves the network host for a project"""
-        network_ref = db.project_get_network(context, context.project.id)
+        network_ref = self.network_manager.get_network(context)
         host = network_ref['host']
         if not host:
             host = rpc.call(FLAGS.network_topic,
                                   {"method": "set_network_host",
                                    "args": {"context": None,
-                                            "project_id": context.project.id}})
+                                            "network_id": network_ref['id']}})
         return db.queue_get_for(context, FLAGS.network_topic, host)
 
     def run_instances(self, context, **kwargs):
@@ -612,12 +612,13 @@ class CloudController(object):
             inst['launch_index'] = num
             inst['hostname'] = instance_ref['ec2_id']
             db.instance_update(context, inst_id, inst)
+            # TODO(vish): This probably should be done in the scheduler
+            #             or in compute as a call.  The network should be
+            #             allocated after the host is assigned and setup
+            #             can happen at the same time.
             address = self.network_manager.allocate_fixed_ip(context,
                                                              inst_id,
                                                              vpn)
-
-            # TODO(vish): This probably should be done in the scheduler
-            #             network is setup when host is assigned
             network_topic = self._get_network_topic(context)
             rpc.call(network_topic,
                      {"method": "setup_fixed_ip",
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 11efd8aef..0606d14bb 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -64,8 +64,8 @@ def _entity_list(entities):
 
 def _entity_detail(inst):
     """ Maps everything to Rackspace-like attributes for return"""
-    power_mapping = { 
-        power_state.NOSTATE:  'build', 
+    power_mapping = {
+        power_state.NOSTATE:  'build',
         power_state.RUNNING:  'active',
         power_state.BLOCKED:  'active',
         power_state.PAUSED:   'suspended',
@@ -75,7 +75,7 @@ def _entity_detail(inst):
     }
     inst_dict = {}
 
-    mapped_keys = dict(status='state', imageId='image_id', 
+    mapped_keys = dict(status='state', imageId='image_id',
         flavorId='instance_type', name='server_name', id='id')
 
     for k, v in mapped_keys.iteritems():
@@ -98,7 +98,7 @@ class Controller(wsgi.Controller):
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
-                "server": [ "id", "imageId", "name", "flavorId", "hostId", 
+                "server": [ "id", "imageId", "name", "flavorId", "hostId",
                             "status", "progress", "progress" ]
             }
         }
@@ -178,7 +178,7 @@ class Controller(wsgi.Controller):
         user_id = req.environ['nova.context']['user']['id']
 
         inst_dict = self._deserialize(req.body, req)
-        
+
         if not inst_dict:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
@@ -186,12 +186,12 @@ class Controller(wsgi.Controller):
         if not instance or instance.user_id != user_id:
             return faults.Fault(exc.HTTPNotFound())
 
-        self.db_driver.instance_update(None, id, 
+        self.db_driver.instance_update(None, id,
             _filter_params(inst_dict['server']))
         return faults.Fault(exc.HTTPNoContent())
 
     def action(self, req, id):
-        """ multi-purpose method used to reboot, rebuild, and 
+        """ multi-purpose method used to reboot, rebuild, and
         resize a server """
         input_dict = self._deserialize(req.body, req)
         try:
@@ -217,13 +217,13 @@ class Controller(wsgi.Controller):
             if v['flavorid'] == flavor_id][0]
 
         image_id = env['server']['imageId']
-        
+
         img_service, image_id_trans = _image_service()
 
-        opaque_image_id = image_id_trans.to_rs_id(image_id)        
+        opaque_image_id = image_id_trans.to_rs_id(image_id)
         image = img_service.show(opaque_image_id)
 
-        if not image: 
+        if not image:
             raise Exception, "Image not found"
 
         inst['server_name'] = env['server']['name']
@@ -259,15 +259,15 @@ class Controller(wsgi.Controller):
 
         ref = self.db_driver.instance_create(None, inst)
         inst['id'] = inst_id_trans.to_rs_id(ref.ec2_id)
-        
+
         # TODO(dietz): this isn't explicitly necessary, but the networking
         # calls depend on an object with a project_id property, and therefore
         # should be cleaned up later
         api_context = context.APIRequestContext(user_id)
-    
+
         inst['mac_address'] = utils.generate_mac()
-        
-        #TODO(dietz) is this necessary? 
+
+        #TODO(dietz) is this necessary?
         inst['launch_index'] = 0
 
         inst['hostname'] = ref.ec2_id
@@ -279,21 +279,20 @@ class Controller(wsgi.Controller):
 
         # TODO(vish): This probably should be done in the scheduler
         #             network is setup when host is assigned
-        network_topic = self._get_network_topic(user_id)
+        network_topic = self._get_network_topic(None)
         rpc.call(network_topic,
                  {"method": "setup_fixed_ip",
                   "args": {"context": None,
                            "address": address}})
         return inst
 
-    def _get_network_topic(self, user_id):
+    def _get_network_topic(self, context):
         """Retrieves the network host for a project"""
-        network_ref = self.db_driver.project_get_network(None, 
-            user_id)
+        network_ref = self.network_manager.get_network(context)
         host = network_ref['host']
         if not host:
             host = rpc.call(FLAGS.network_topic,
                                   {"method": "set_network_host",
                                    "args": {"context": None,
-                                            "project_id": user_id}})
+                                            "network_id": network_ref['id']}})
         return self.db_driver.queue_get_for(None, FLAGS.network_topic, host)
-- 
cgit 


From 0ef621d47eeea421820a2191de53dee9e83d8c44 Mon Sep 17 00:00:00 2001
From: "jaypipes@gmail.com" <>
Date: Fri, 1 Oct 2010 16:06:14 -0400
Subject: Adds BaseImageService and flag to control image service loading. 
 Adds unit test for local image service.

---
 nova/api/rackspace/images.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 4a7dd489c..d4ab8ce3c 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -17,12 +17,17 @@
 
 from webob import exc
 
+from nova import flags
+from nova import utils
 from nova import wsgi
 from nova.api.rackspace import _id_translator
 import nova.api.rackspace
 import nova.image.service
 from nova.api.rackspace import faults
 
+
+FLAGS = flags.FLAGS
+
 class Controller(wsgi.Controller):
 
     _serialization_metadata = {
@@ -35,7 +40,7 @@ class Controller(wsgi.Controller):
     }
 
     def __init__(self):
-        self._service = nova.image.service.ImageService.load()
+        self._service = utils.import_object(FLAGS.image_service)
         self._id_translator = _id_translator.RackspaceAPIIdTranslator(
                 "image", self._service.__class__.__name__)
 
-- 
cgit 


From 5c4b1a38b8a82ee0a8f14f813f91d319a9715cc3 Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Mon, 4 Oct 2010 16:01:44 +0000
Subject: More clean up and conflict resolution

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 2fec49da8..f43da42bd 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -719,7 +719,7 @@ class CloudController(object):
                 changes[field] = kwargs[field]
         if changes:
             db_context = {}
-            internal_id = ec2_id_to_internal_id(ec2_id)
+            internal_id = self.ec2_id_to_internal_id(ec2_id)
             inst = db.instance_get_by_internal_id(db_context, internal_id)
             db.instance_update(db_context, inst['id'], kwargs)
         return True
-- 
cgit 


From a4720c03a8260fb920035d072799d3ecc478db99 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Mon, 4 Oct 2010 21:58:22 +0200
Subject: Merge security group related changes from lp:~anso/nova/deploy

---
 nova/api/ec2/cloud.py | 31 ++++++++++++++++++++++++++-----
 1 file changed, 26 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 839b84b4e..4cd4c78ae 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -327,6 +327,26 @@ class CloudController(object):
 
         return values
 
+
+    def _security_group_rule_exists(self, security_group, values):
+        """Indicates whether the specified rule values are already
+           defined in the given security group.
+        """
+        for rule in security_group.rules:
+            if 'group_id' in values:
+                if rule['group_id'] == values['group_id']:
+                    return True
+            else:
+                is_duplicate = True
+                for key in ('cidr', 'from_port', 'to_port', 'protocol'):
+                    if rule[key] != values[key]:
+                        is_duplicate = False
+                        break
+                if is_duplicate:
+                    return True
+        return False
+
+
     def revoke_security_group_ingress(self, context, group_name, **kwargs):
         self._ensure_default_security_group(context)
         security_group = db.security_group_get_by_name(context,
@@ -348,9 +368,6 @@ class CloudController(object):
                 return True
         raise exception.ApiError("No rule for the specified parameters.")
 
-    # TODO(soren): Dupe detection. Adding the same rule twice actually
-    #              adds the same rule twice to the rule set, which is
-    #              pointless.
     # TODO(soren): This has only been tested with Boto as the client.
     #              Unfortunately, it seems Boto is using an old API
     #              for these operations, so support for newer API versions
@@ -364,6 +381,10 @@ class CloudController(object):
         values = self._authorize_revoke_rule_args_to_dict(context, **kwargs)
         values['parent_group_id'] = security_group.id
 
+        if self._security_group_rule_exists(security_group, values):
+            raise exception.ApiError('This rule already exists in group %s' %
+                                     group_name)
+
         security_group_rule = db.security_group_rule_create(context, values)
 
         self._trigger_refresh_security_group(security_group)
@@ -709,7 +730,7 @@ class CloudController(object):
                        'description' : 'default',
                        'user_id'     : context.user.id,
                        'project_id'  : context.project.id }
-            group = db.security_group_create({}, values)
+            group = db.security_group_create(context, values)
 
     def run_instances(self, context, **kwargs):
         instance_type = kwargs.get('instance_type', 'm1.small')
@@ -797,7 +818,7 @@ class CloudController(object):
             inst_id = instance_ref['id']
 
             for security_group_id in security_groups:
-                db.instance_add_security_group(context, inst_id,
+                db.instance_add_security_group(context.admin(), inst_id,
                                                security_group_id)
 
             inst = {}
-- 
cgit 


From dd0f365c98ae68afff9a0fbc75e7d5b88499b282 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 4 Oct 2010 16:39:05 -0400
Subject: Fix broken unit tests

---
 nova/api/ec2/cloud.py | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 2fec49da8..7f5f4c4e9 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -72,6 +72,20 @@ def _gen_key(context, user_id, key_name):
     return {'private_key': private_key, 'fingerprint': fingerprint}
 
 
+def ec2_id_to_internal_id(ec2_id):
+    """Convert an ec2 ID (i-[base 36 number]) to an internal id (int)"""
+    return int(ec2_id[2:], 36)
+
+
+def internal_id_to_ec2_id(internal_id):
+    """Convert an internal ID (int) to an ec2 ID (i-[base 36 number])"""
+    digits = []
+    while internal_id != 0:
+        internal_id, remainder = divmod(internal_id, 36)
+        digits.append('0123456789abcdefghijklmnopqrstuvwxyz'[remainder])
+    return "i-%s" % ''.join(reversed(digits))
+
+
 class CloudController(object):
     """ CloudController provides the critical dispatch between
  inbound API calls through the endpoint and messages
@@ -113,16 +127,6 @@ class CloudController(object):
                     result[key] = [line]
         return result
 
-    def ec2_id_to_internal_id(ec2_id):
-        """Convert an ec2 ID (i-[base 36 number]) to an internal id (int)"""
-        # TODO(gundlach): Maybe this should actually work?
-        return ec2_id[2:]
-
-    def internal_id_to_ec2_id(internal_id):
-        """Convert an internal ID (int) to an ec2 ID (i-[base 36 number])"""
-        # TODO(gundlach): Yo maybe this should actually convert to base 36
-        return "i-%d" % internal_id
-
     def get_metadata(self, address):
         instance_ref = db.fixed_ip_get_instance(None, address)
         if instance_ref is None:
-- 
cgit 


From 6bdbb567f1a9e0a8b980ff916183d47375fe11bf Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Mon, 4 Oct 2010 21:20:33 +0000
Subject: One last bad line

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 3f440c85c..7f5f4c4e9 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -723,7 +723,7 @@ class CloudController(object):
                 changes[field] = kwargs[field]
         if changes:
             db_context = {}
-            internal_id = self.ec2_id_to_internal_id(ec2_id)
+            internal_id = ec2_id_to_internal_id(ec2_id)
             inst = db.instance_get_by_internal_id(db_context, internal_id)
             db.instance_update(db_context, inst['id'], kwargs)
         return True
-- 
cgit 


From 1158e1817b7d39e9655b219ede865f301153e713 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Tue, 5 Oct 2010 11:17:03 +0200
Subject: Un-twistedify get_console_ouptut.

---
 nova/api/ec2/cloud.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 1f01731ae..e7147ec05 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -247,16 +247,16 @@ class CloudController(object):
     def get_console_output(self, context, instance_id, **kwargs):
         # instance_id is passed in as a list of instances
         instance_ref = db.instance_get_by_ec2_id(context, instance_id[0])
-        d = rpc.call('%s.%s' % (FLAGS.compute_topic,
+        output = rpc.call('%s.%s' % (FLAGS.compute_topic,
                                 instance_ref['host']),
                      { "method" : "get_console_output",
                        "args"   : { "context": None,
                                     "instance_id": instance_ref['id']}})
 
-        d.addCallback(lambda output: { "InstanceId": instance_id,
-                                       "Timestamp": "2",
-                                       "output": base64.b64encode(output)})
-        return d
+        now = datetime.datetime.utcnow()
+        return { "InstanceId" : instance_id,
+                 "Timestamp"  : now,
+                 "output"     : base64.b64encode(output) }
 
     def describe_volumes(self, context, **kwargs):
         if context.user.is_admin():
-- 
cgit 


From 10bbf9f638b5c8c9182984cc7e22f732b194476f Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Tue, 5 Oct 2010 15:21:31 +0200
Subject: Stub out ec2.images.list() for unit tests.

---
 nova/api/ec2/images.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'nova/api')

diff --git a/nova/api/ec2/images.py b/nova/api/ec2/images.py
index cb54cdda2..f0a43dad6 100644
--- a/nova/api/ec2/images.py
+++ b/nova/api/ec2/images.py
@@ -69,6 +69,9 @@ def list(context, filter_list=[]):
 
     optionally filtered by a list of image_id """
 
+    if FLAGS.connection_type == 'fake':
+        return [{ 'imageId' : 'bar'}]
+
     # FIXME: send along the list of only_images to check for
     response = conn(context).make_request(
             method='GET',
-- 
cgit 


From c86462d11a6709bf9f2130056bf04712fe3db2d9 Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Tue, 5 Oct 2010 20:07:11 +0000
Subject: merge prop fixes

---
 nova/api/rackspace/servers.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 868b697e0..5cfb7a431 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -129,7 +129,7 @@ class Controller(wsgi.Controller):
     def show(self, req, id):
         """ Returns server details by server id """
         user_id = req.environ['nova.context']['user']['id']
-        inst = self.db_driver.instance_get_by_internal_id(None, id)
+        inst = self.db_driver.instance_get_by_internal_id(None, int(id))
         if inst:
             if inst.user_id == user_id:
                 return _entity_detail(inst)
@@ -138,7 +138,7 @@ class Controller(wsgi.Controller):
     def delete(self, req, id):
         """ Destroys a server """
         user_id = req.environ['nova.context']['user']['id']
-        instance = self.db_driver.instance_get_by_internal_id(None, id)
+        instance = self.db_driver.instance_get_by_internal_id(None, int(id))
         if instance and instance['user_id'] == user_id:
             self.db_driver.instance_destroy(None, id)
             return faults.Fault(exc.HTTPAccepted())
@@ -171,11 +171,11 @@ class Controller(wsgi.Controller):
         if not inst_dict:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
-        instance = self.db_driver.instance_get_by_internal_id(None, id)
+        instance = self.db_driver.instance_get_by_internal_id(None, int(id))
         if not instance or instance.user_id != user_id:
             return faults.Fault(exc.HTTPNotFound())
 
-        self.db_driver.instance_update(None, id, 
+        self.db_driver.instance_update(None, int(id), 
             _filter_params(inst_dict['server']))
         return faults.Fault(exc.HTTPNoContent())
 
@@ -187,7 +187,7 @@ class Controller(wsgi.Controller):
             reboot_type = input_dict['reboot']['type']
         except Exception:
             raise faults.Fault(webob.exc.HTTPNotImplemented())
-        opaque_id = _instance_id_translator().from_rs_id(id)
+        opaque_id = _instance_id_translator().from_rs_id(int(id))
         cloud.reboot(opaque_id)
 
     def _build_server_instance(self, req, env):
@@ -257,7 +257,7 @@ class Controller(wsgi.Controller):
         #TODO(dietz) is this necessary? 
         inst['launch_index'] = 0
 
-        inst['hostname'] = ref.internal_id
+        inst['hostname'] = str(ref.internal_id)
         self.db_driver.instance_update(None, inst['id'], inst)
 
         network_manager = utils.import_object(FLAGS.network_manager)
-- 
cgit 


From db620f323c2fc5e65a722a33ae8a42b54817dae1 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Tue, 5 Oct 2010 16:16:42 -0400
Subject: Missed an ec2_id conversion to internal_id

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 7f5f4c4e9..175bb493c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -262,7 +262,7 @@ class CloudController(object):
         # ec2_id_list is passed in as a list of instances
         ec2_id = ec2_id_list[0]
         internal_id = ec2_id_to_internal_id(ec2_id)
-        instance_ref = db.instance_get_by_ec2_id(context, internal_id)
+        instance_ref = db.instance_get_by_internal_id(context, internal_id)
         return rpc.call('%s.%s' % (FLAGS.compute_topic,
                                    instance_ref['host']),
                         {"method": "get_console_output",
-- 
cgit 


From fbd1bc015bd5615963b9073eefb895ea04c55a3e Mon Sep 17 00:00:00 2001
From: "jaypipes@gmail.com" <>
Date: Tue, 5 Oct 2010 16:19:55 -0400
Subject: Merge overwrote import_object() load of image service.

---
 nova/api/rackspace/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index 5cfb7a431..b23867bbf 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -42,7 +42,7 @@ def _instance_id_translator():
 
 def _image_service():
     """ Helper method for initializing the image id translator """
-    service = nova.image.service.ImageService.load()
+    service = utils.import_object(FLAGS.image_service)
     return (service, _id_translator.RackspaceAPIIdTranslator(
             "image", service.__class__.__name__))
 
-- 
cgit 


From db87fd5a8145d045c4767a8d02cde5a0750113f8 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Fri, 8 Oct 2010 12:21:26 -0400
Subject: Remove redis dependency from Images controller.

LocalImageService now works with integer ids, so there's no need for the translator.

Once Glance exists we'll have to revisit this.
---
 nova/api/rackspace/backup_schedules.py |  1 -
 nova/api/rackspace/images.py           | 10 +---------
 2 files changed, 1 insertion(+), 10 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/backup_schedules.py b/nova/api/rackspace/backup_schedules.py
index cb83023bc..9c0d41fa0 100644
--- a/nova/api/rackspace/backup_schedules.py
+++ b/nova/api/rackspace/backup_schedules.py
@@ -19,7 +19,6 @@ import time
 from webob import exc
 
 from nova import wsgi
-from nova.api.rackspace import _id_translator
 from nova.api.rackspace import faults
 import nova.image.service
 
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index d4ab8ce3c..82dcd2049 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -20,7 +20,6 @@ from webob import exc
 from nova import flags
 from nova import utils
 from nova import wsgi
-from nova.api.rackspace import _id_translator
 import nova.api.rackspace
 import nova.image.service
 from nova.api.rackspace import faults
@@ -41,8 +40,6 @@ class Controller(wsgi.Controller):
 
     def __init__(self):
         self._service = utils.import_object(FLAGS.image_service)
-        self._id_translator = _id_translator.RackspaceAPIIdTranslator(
-                "image", self._service.__class__.__name__)
 
     def index(self, req):
         """Return all public images in brief."""
@@ -53,16 +50,11 @@ class Controller(wsgi.Controller):
         """Return all public images in detail."""
         data = self._service.index()
         data = nova.api.rackspace.limited(data, req)
-        for img in data:
-            img['id'] = self._id_translator.to_rs_id(img['id'])
         return dict(images=data)
 
     def show(self, req, id):
         """Return data about the given image id."""
-        opaque_id = self._id_translator.from_rs_id(id)
-        img = self._service.show(opaque_id)
-        img['id'] = id
-        return dict(image=img)
+        return dict(image=self._service.show(id))
 
     def delete(self, req, id):
         # Only public images are supported for now.
-- 
cgit 


From f1a48207dfc1948ba847f262d5a4ff825b02202c Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Fri, 8 Oct 2010 18:56:32 +0000
Subject: Start stripping out the translators

---
 nova/api/rackspace/servers.py | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index b23867bbf..8c489ed83 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -25,7 +25,6 @@ from nova import rpc
 from nova import utils
 from nova import wsgi
 from nova.api import cloud
-from nova.api.rackspace import _id_translator
 from nova.api.rackspace import context
 from nova.api.rackspace import faults
 from nova.compute import instance_types
@@ -35,11 +34,6 @@ import nova.image.service
 
 FLAGS = flags.FLAGS
 
-def _instance_id_translator():
-    """ Helper method for initializing an id translator for Rackspace instance
-    ids """
-    return _id_translator.RackspaceAPIIdTranslator( "instance", 'nova')
-
 def _image_service():
     """ Helper method for initializing the image id translator """
     service = utils.import_object(FLAGS.image_service)
@@ -182,13 +176,16 @@ class Controller(wsgi.Controller):
     def action(self, req, id):
         """ multi-purpose method used to reboot, rebuild, and 
         resize a server """
+	user_id = req.environ['nova.context']['user']['id']
         input_dict = self._deserialize(req.body, req)
         try:
             reboot_type = input_dict['reboot']['type']
         except Exception:
             raise faults.Fault(webob.exc.HTTPNotImplemented())
-        opaque_id = _instance_id_translator().from_rs_id(int(id))
-        cloud.reboot(opaque_id)
+	inst_ref = self.db.instance_get_by_internal_id(None, int(id))
+	if not inst_ref or (inst_ref and not inst_ref.user_id == user_id):
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        cloud.reboot(id)
 
     def _build_server_instance(self, req, env):
         """Build instance data structure and save it to the data store."""
-- 
cgit 


From 90f38090ecd586a39257b3efd2c86c2c60b7fdb9 Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Fri, 8 Oct 2010 20:39:00 +0000
Subject: Mass renaming

---
 nova/api/__init__.py                        |   4 +-
 nova/api/openstack/__init__.py              | 190 +++++++++++++++++++
 nova/api/openstack/_id_translator.py        |  42 +++++
 nova/api/openstack/auth.py                  | 101 ++++++++++
 nova/api/openstack/backup_schedules.py      |  38 ++++
 nova/api/openstack/context.py               |  33 ++++
 nova/api/openstack/faults.py                |  62 ++++++
 nova/api/openstack/flavors.py               |  58 ++++++
 nova/api/openstack/images.py                |  71 +++++++
 nova/api/openstack/notes.txt                |  23 +++
 nova/api/openstack/ratelimiting/__init__.py | 122 ++++++++++++
 nova/api/openstack/servers.py               | 276 +++++++++++++++++++++++++++
 nova/api/openstack/sharedipgroups.py        |  20 ++
 nova/api/rackspace/__init__.py              | 190 -------------------
 nova/api/rackspace/_id_translator.py        |  42 -----
 nova/api/rackspace/auth.py                  | 101 ----------
 nova/api/rackspace/backup_schedules.py      |  38 ----
 nova/api/rackspace/context.py               |  33 ----
 nova/api/rackspace/faults.py                |  62 ------
 nova/api/rackspace/flavors.py               |  58 ------
 nova/api/rackspace/images.py                |  71 -------
 nova/api/rackspace/notes.txt                |  23 ---
 nova/api/rackspace/ratelimiting/__init__.py | 122 ------------
 nova/api/rackspace/ratelimiting/tests.py    | 237 -----------------------
 nova/api/rackspace/servers.py               | 283 ----------------------------
 nova/api/rackspace/sharedipgroups.py        |  20 --
 26 files changed, 1038 insertions(+), 1282 deletions(-)
 create mode 100644 nova/api/openstack/__init__.py
 create mode 100644 nova/api/openstack/_id_translator.py
 create mode 100644 nova/api/openstack/auth.py
 create mode 100644 nova/api/openstack/backup_schedules.py
 create mode 100644 nova/api/openstack/context.py
 create mode 100644 nova/api/openstack/faults.py
 create mode 100644 nova/api/openstack/flavors.py
 create mode 100644 nova/api/openstack/images.py
 create mode 100644 nova/api/openstack/notes.txt
 create mode 100644 nova/api/openstack/ratelimiting/__init__.py
 create mode 100644 nova/api/openstack/servers.py
 create mode 100644 nova/api/openstack/sharedipgroups.py
 delete mode 100644 nova/api/rackspace/__init__.py
 delete mode 100644 nova/api/rackspace/_id_translator.py
 delete mode 100644 nova/api/rackspace/auth.py
 delete mode 100644 nova/api/rackspace/backup_schedules.py
 delete mode 100644 nova/api/rackspace/context.py
 delete mode 100644 nova/api/rackspace/faults.py
 delete mode 100644 nova/api/rackspace/flavors.py
 delete mode 100644 nova/api/rackspace/images.py
 delete mode 100644 nova/api/rackspace/notes.txt
 delete mode 100644 nova/api/rackspace/ratelimiting/__init__.py
 delete mode 100644 nova/api/rackspace/ratelimiting/tests.py
 delete mode 100644 nova/api/rackspace/servers.py
 delete mode 100644 nova/api/rackspace/sharedipgroups.py

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 744abd621..627883018 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -27,7 +27,7 @@ from nova import flags
 from nova import wsgi
 from nova.api import cloudpipe
 from nova.api import ec2
-from nova.api import rackspace
+from nova.api import openstack
 from nova.api.ec2 import metadatarequesthandler
 
 
@@ -57,7 +57,7 @@ class API(wsgi.Router):
         mapper.sub_domains = True
         mapper.connect("/", controller=self.rsapi_versions, 
                             conditions=rsdomain)
-        mapper.connect("/v1.0/{path_info:.*}", controller=rackspace.API(),
+        mapper.connect("/v1.0/{path_info:.*}", controller=openstack.API(),
                             conditions=rsdomain)
 
         mapper.connect("/", controller=self.ec2api_versions,
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
new file mode 100644
index 000000000..5e81ba2bd
--- /dev/null
+++ b/nova/api/openstack/__init__.py
@@ -0,0 +1,190 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+WSGI middleware for OpenStack API controllers.
+"""
+
+import json
+import time
+
+import routes
+import webob.dec
+import webob.exc
+import webob
+
+from nova import flags
+from nova import utils
+from nova import wsgi
+from nova.api.openstack import faults
+from nova.api.openstack import backup_schedules
+from nova.api.openstack import flavors
+from nova.api.openstack import images
+from nova.api.openstack import ratelimiting
+from nova.api.openstack import servers
+from nova.api.openstack import sharedipgroups
+from nova.auth import manager
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('nova_api_auth',
+    'nova.api.openstack.auth.BasicApiAuthManager', 
+    'The auth mechanism to use for the OpenStack API implemenation')
+
+class API(wsgi.Middleware):
+    """WSGI entry point for all OpenStack API requests."""
+
+    def __init__(self):
+        app = AuthMiddleware(RateLimitingMiddleware(APIRouter()))
+        super(API, self).__init__(app)
+
+class AuthMiddleware(wsgi.Middleware):
+    """Authorize the openstack API request or return an HTTP Forbidden."""
+
+    def __init__(self, application):
+        self.auth_driver = utils.import_class(FLAGS.nova_api_auth)()
+        super(AuthMiddleware, self).__init__(application)
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        if not req.headers.has_key("X-Auth-Token"):
+            return self.auth_driver.authenticate(req)
+
+        user = self.auth_driver.authorize_token(req.headers["X-Auth-Token"])
+
+        if not user:
+            return faults.Fault(webob.exc.HTTPUnauthorized())
+
+        if not req.environ.has_key('nova.context'):
+            req.environ['nova.context'] = {}
+        req.environ['nova.context']['user'] = user
+        return self.application
+
+class RateLimitingMiddleware(wsgi.Middleware):
+    """Rate limit incoming requests according to the OpenStack rate limits."""
+
+    def __init__(self, application, service_host=None):
+        """Create a rate limiting middleware that wraps the given application.
+
+        By default, rate counters are stored in memory.  If service_host is
+        specified, the middleware instead relies on the ratelimiting.WSGIApp
+        at the given host+port to keep rate counters.
+        """
+        super(RateLimitingMiddleware, self).__init__(application)
+        if not service_host:
+            #TODO(gundlach): These limits were based on limitations of Cloud 
+            #Servers.  We should revisit them in Nova.
+            self.limiter = ratelimiting.Limiter(limits={
+                    'DELETE': (100, ratelimiting.PER_MINUTE),
+                    'PUT': (10, ratelimiting.PER_MINUTE),
+                    'POST': (10, ratelimiting.PER_MINUTE),
+                    'POST servers': (50, ratelimiting.PER_DAY),
+                    'GET changes-since': (3, ratelimiting.PER_MINUTE),
+                })
+        else:
+            self.limiter = ratelimiting.WSGIAppProxy(service_host)
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        """Rate limit the request.
+        
+        If the request should be rate limited, return a 413 status with a 
+        Retry-After header giving the time when the request would succeed.
+        """
+        username = req.headers['X-Auth-User']
+        action_name = self.get_action_name(req)
+        if not action_name: # not rate limited
+            return self.application
+        delay = self.get_delay(action_name, username)
+        if delay:
+            # TODO(gundlach): Get the retry-after format correct.
+            exc = webob.exc.HTTPRequestEntityTooLarge(
+                    explanation='Too many requests.',
+                    headers={'Retry-After': time.time() + delay})
+            raise faults.Fault(exc)
+        return self.application
+
+    def get_delay(self, action_name, username):
+        """Return the delay for the given action and username, or None if
+        the action would not be rate limited.
+        """
+        if action_name == 'POST servers':
+            # "POST servers" is a POST, so it counts against "POST" too.
+            # Attempt the "POST" first, lest we are rate limited by "POST" but
+            # use up a precious "POST servers" call.
+            delay = self.limiter.perform("POST", username=username)
+            if delay:
+                return delay
+        return self.limiter.perform(action_name, username=username)
+
+    def get_action_name(self, req):
+        """Return the action name for this request."""
+        if req.method == 'GET' and 'changes-since' in req.GET:
+            return 'GET changes-since'
+        if req.method == 'POST' and req.path_info.startswith('/servers'):
+            return 'POST servers'
+        if req.method in ['PUT', 'POST', 'DELETE']:
+            return req.method
+        return None
+
+
+class APIRouter(wsgi.Router):
+    """
+    Routes requests on the OpenStack API to the appropriate controller
+    and method.
+    """
+
+    def __init__(self):
+        mapper = routes.Mapper()
+        mapper.resource("server", "servers", controller=servers.Controller(),
+                        collection={ 'detail': 'GET'},
+                        member={'action':'POST'})
+
+        mapper.resource("backup_schedule", "backup_schedules", 
+                        controller=backup_schedules.Controller(),
+                        parent_resource=dict(member_name='server', 
+                        collection_name = 'servers')) 
+
+        mapper.resource("image", "images", controller=images.Controller(),
+                        collection={'detail': 'GET'})
+        mapper.resource("flavor", "flavors", controller=flavors.Controller(),
+                        collection={'detail': 'GET'})
+        mapper.resource("sharedipgroup", "sharedipgroups",
+                        controller=sharedipgroups.Controller())
+
+        super(APIRouter, self).__init__(mapper)
+
+
+def limited(items, req):
+    """Return a slice of items according to requested offset and limit.
+    
+    items - a sliceable
+    req - wobob.Request possibly containing offset and limit GET variables.
+          offset is where to start in the list, and limit is the maximum number
+          of items to return.
+
+    If limit is not specified, 0, or > 1000, defaults to 1000.
+    """
+    offset = int(req.GET.get('offset', 0))
+    limit = int(req.GET.get('limit', 0))
+    if not limit:
+        limit = 1000
+    limit = min(1000, limit)
+    range_end = offset + limit
+    return items[offset:range_end]
+
diff --git a/nova/api/openstack/_id_translator.py b/nova/api/openstack/_id_translator.py
new file mode 100644
index 000000000..333aa8434
--- /dev/null
+++ b/nova/api/openstack/_id_translator.py
@@ -0,0 +1,42 @@
+from nova import datastore
+
+class RackspaceAPIIdTranslator(object):
+    """
+    Converts Rackspace API ids to and from the id format for a given
+    strategy.
+    """
+
+    def __init__(self, id_type, service_name):
+        """
+        Creates a translator for ids of the given type (e.g. 'flavor'), for the
+        given storage service backend class name (e.g. 'LocalFlavorService').
+        """
+
+        self._store = datastore.Redis.instance()
+        key_prefix = "rsapi.idtranslator.%s.%s" % (id_type, service_name)
+        # Forward (strategy format -> RS format) and reverse translation keys
+        self._fwd_key = "%s.fwd" % key_prefix
+        self._rev_key = "%s.rev" % key_prefix
+
+    def to_rs_id(self, opaque_id):
+        """Convert an id from a strategy-specific one to a Rackspace one."""
+        result = self._store.hget(self._fwd_key, str(opaque_id))
+        if result: # we have a mapping from opaque to RS for this strategy
+            return int(result)
+        else:
+            # Store the mapping.
+            nextid = self._store.incr("%s.lastid" % self._fwd_key)
+            if self._store.hsetnx(self._fwd_key, str(opaque_id), nextid):
+                # If someone else didn't beat us to it, store the reverse
+                # mapping as well.
+                self._store.hset(self._rev_key, nextid, str(opaque_id))
+                return nextid
+            else:
+                # Someone beat us to it; use their number instead, and
+                # discard nextid (which is OK -- we don't require that
+                # every int id be used.)
+                return int(self._store.hget(self._fwd_key, str(opaque_id)))
+
+    def from_rs_id(self, rs_id):
+        """Convert a Rackspace id to a strategy-specific one."""
+        return self._store.hget(self._rev_key, rs_id)
diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
new file mode 100644
index 000000000..4c909293e
--- /dev/null
+++ b/nova/api/openstack/auth.py
@@ -0,0 +1,101 @@
+import datetime
+import hashlib
+import json
+import time
+
+import webob.exc
+import webob.dec
+
+from nova import auth
+from nova import db
+from nova import flags
+from nova import manager
+from nova import utils
+from nova.api.openstack import faults
+
+FLAGS = flags.FLAGS
+
+class Context(object):
+    pass
+
+class BasicApiAuthManager(object):
+    """ Implements a somewhat rudimentary version of OpenStack Auth"""
+
+    def __init__(self, host=None, db_driver=None):
+        if not host:
+            host = FLAGS.host
+        self.host = host                                                                                                                                     
+        if not db_driver:
+            db_driver = FLAGS.db_driver                                                                                                                      
+        self.db = utils.import_object(db_driver)
+        self.auth = auth.manager.AuthManager()
+        self.context = Context()
+        super(BasicApiAuthManager, self).__init__()
+
+    def authenticate(self, req):
+        # Unless the request is explicitly made against /<version>/ don't
+        # honor it
+        path_info = req.path_info
+        if len(path_info) > 1:
+            return faults.Fault(webob.exc.HTTPUnauthorized())
+
+        try:
+            username, key = req.headers['X-Auth-User'], \
+                req.headers['X-Auth-Key']
+        except KeyError:
+            return faults.Fault(webob.exc.HTTPUnauthorized())
+
+        username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
+        token, user = self._authorize_user(username, key)
+        if user and token:
+            res = webob.Response()
+            res.headers['X-Auth-Token'] = token['token_hash']
+            res.headers['X-Server-Management-Url'] = \
+                token['server_management_url']
+            res.headers['X-Storage-Url'] = token['storage_url']
+            res.headers['X-CDN-Management-Url'] = token['cdn_management_url']
+            res.content_type = 'text/plain'
+            res.status = '204'
+            return res
+        else:
+            return faults.Fault(webob.exc.HTTPUnauthorized())
+
+    def authorize_token(self, token_hash):
+        """ retrieves user information from the datastore given a token
+        
+        If the token has expired, returns None
+        If the token is not found, returns None
+        Otherwise returns the token
+
+        This method will also remove the token if the timestamp is older than
+        2 days ago.
+        """
+        token = self.db.auth_get_token(self.context, token_hash) 
+        if token:
+            delta = datetime.datetime.now() - token['created_at']
+            if delta.days >= 2:
+                self.db.auth_destroy_token(self.context, token)
+            else:
+                user = self.auth.get_user(token['user_id'])
+                return { 'id':user['uid'] }
+        return None
+
+    def _authorize_user(self, username, key):
+        """ Generates a new token and assigns it to a user """
+        user = self.auth.get_user_from_access_key(key)
+        if user and user['name'] == username:
+            token_hash = hashlib.sha1('%s%s%f' % (username, key,
+                time.time())).hexdigest()
+            token = {}
+            token['token_hash'] = token_hash
+            token['cdn_management_url'] = ''
+            token['server_management_url'] = self._get_server_mgmt_url()
+            token['storage_url'] = ''
+            token['user_id'] = user['uid']
+            self.db.auth_create_token(self.context, token)
+            return token, user
+        return None, None 
+
+    def _get_server_mgmt_url(self):
+        return 'https://%s/v1.0/' % self.host
+        
diff --git a/nova/api/openstack/backup_schedules.py b/nova/api/openstack/backup_schedules.py
new file mode 100644
index 000000000..76ad6ef87
--- /dev/null
+++ b/nova/api/openstack/backup_schedules.py
@@ -0,0 +1,38 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import time
+from webob import exc
+
+from nova import wsgi
+from nova.api.openstack import faults
+import nova.image.service
+
+class Controller(wsgi.Controller):
+    def __init__(self):
+        pass
+
+    def index(self, req, server_id):
+        return faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req, server_id):
+        """ No actual update method required, since the existing API allows
+        both create and update through a POST """
+        return faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, server_id):
+        return faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/openstack/context.py b/nova/api/openstack/context.py
new file mode 100644
index 000000000..77394615b
--- /dev/null
+++ b/nova/api/openstack/context.py
@@ -0,0 +1,33 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+APIRequestContext
+"""
+
+import random
+
+class Project(object):
+    def __init__(self, user_id):
+        self.id = user_id
+    
+class APIRequestContext(object):
+    """ This is an adapter class to get around all of the assumptions made in
+    the FlatNetworking """
+    def __init__(self, user_id):
+        self.user_id = user_id
+        self.project = Project(user_id)
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
new file mode 100644
index 000000000..32e5c866f
--- /dev/null
+++ b/nova/api/openstack/faults.py
@@ -0,0 +1,62 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+import webob.dec
+import webob.exc
+
+from nova import wsgi
+
+
+class Fault(webob.exc.HTTPException):
+
+    """An RS API fault response."""
+
+    _fault_names = {
+            400: "badRequest",
+            401: "unauthorized",
+            403: "resizeNotAllowed",
+            404: "itemNotFound",
+            405: "badMethod",
+            409: "inProgress",
+            413: "overLimit",
+            415: "badMediaType",
+            501: "notImplemented",
+            503: "serviceUnavailable"}
+
+    def __init__(self, exception):
+        """Create a Fault for the given webob.exc.exception."""
+        self.wrapped_exc = exception
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        """Generate a WSGI response based on the exception passed to ctor."""
+        # Replace the body with fault details.
+        code = self.wrapped_exc.status_int
+        fault_name = self._fault_names.get(code, "cloudServersFault")
+        fault_data = {
+            fault_name: {
+                'code': code,
+                'message': self.wrapped_exc.explanation}}
+        if code == 413:
+            retry = self.wrapped_exc.headers['Retry-After']
+            fault_data[fault_name]['retryAfter'] = retry
+        # 'code' is an attribute on the fault tag itself 
+        metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
+        serializer = wsgi.Serializer(req.environ, metadata)
+        self.wrapped_exc.body = serializer.to_content_type(fault_data)
+        return self.wrapped_exc
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
new file mode 100644
index 000000000..793984a5d
--- /dev/null
+++ b/nova/api/openstack/flavors.py
@@ -0,0 +1,58 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from webob import exc
+
+from nova.api.openstack import faults
+from nova.compute import instance_types
+from nova import wsgi
+import nova.api.openstack
+
+class Controller(wsgi.Controller):
+    """Flavor controller for the OpenStack API."""
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "flavor": [ "id", "name", "ram", "disk" ]
+            }
+        }
+    }
+
+    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']])
+
+    def detail(self, req):
+        """Return all flavors in detail."""
+        items = [self.show(req, id)['flavor'] for id in self._all_ids()]
+        items = nova.api.openstack.limited(items, req)
+        return dict(flavors=items)
+
+    def show(self, req, id):
+        """Return data about the given flavor id."""
+        for name, val in instance_types.INSTANCE_TYPES.iteritems():
+            if val['flavorid'] == int(id):
+                item = dict(ram=val['memory_mb'], disk=val['local_gb'],
+                            id=val['flavorid'], name=name)
+                return dict(flavor=item)
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def _all_ids(self):
+        """Return the list of all flavorids."""
+        return [i['flavorid'] for i in instance_types.INSTANCE_TYPES.values()]
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
new file mode 100644
index 000000000..aa438739c
--- /dev/null
+++ b/nova/api/openstack/images.py
@@ -0,0 +1,71 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from webob import exc
+
+from nova import flags
+from nova import utils
+from nova import wsgi
+import nova.api.openstack
+import nova.image.service
+from nova.api.openstack import faults
+
+
+FLAGS = flags.FLAGS
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "image": [ "id", "name", "updated", "created", "status",
+                           "serverId", "progress" ]
+            }
+        }
+    }
+
+    def __init__(self):
+        self._service = utils.import_object(FLAGS.image_service)
+
+    def index(self, req):
+        """Return all public images in brief."""
+        return dict(images=[dict(id=img['id'], name=img['name'])
+                            for img in self.detail(req)['images']])
+
+    def detail(self, req):
+        """Return all public images in detail."""
+        data = self._service.index()
+        data = nova.api.openstack.limited(data, req)
+        return dict(images=data)
+
+    def show(self, req, id):
+        """Return data about the given image id."""
+        return dict(image=self._service.show(id))
+
+    def delete(self, req, id):
+        # Only public images are supported for now.
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req):
+        # Only public images are supported for now, so a request to
+        # make a backup of a server cannot be supproted.
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def update(self, req, id):
+        # Users may not modify public images, and that's all that 
+        # we support for now.
+        raise faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/openstack/notes.txt b/nova/api/openstack/notes.txt
new file mode 100644
index 000000000..2330f1002
--- /dev/null
+++ b/nova/api/openstack/notes.txt
@@ -0,0 +1,23 @@
+We will need:
+
+ImageService
+a service that can do crud on image information.  not user-specific. opaque
+image ids.
+
+GlanceImageService(ImageService):
+image ids are URIs.
+
+LocalImageService(ImageService):
+image ids are random strings.
+
+OpenstackAPITranslationStore:
+translates RS server/images/flavor/etc ids into formats required
+by a given ImageService strategy.
+
+api.openstack.images.Controller:
+uses an ImageService strategy behind the scenes to do its fetching; it just
+converts int image id into a strategy-specific image id.
+
+who maintains the mapping from user to [images he owns]?  nobody, because
+we have no way of enforcing access to his images, without kryptex which
+won't be in Austin.
diff --git a/nova/api/openstack/ratelimiting/__init__.py b/nova/api/openstack/ratelimiting/__init__.py
new file mode 100644
index 000000000..f843bac0f
--- /dev/null
+++ b/nova/api/openstack/ratelimiting/__init__.py
@@ -0,0 +1,122 @@
+"""Rate limiting of arbitrary actions."""
+
+import httplib
+import time
+import urllib
+import webob.dec
+import webob.exc
+
+
+# Convenience constants for the limits dictionary passed to Limiter().
+PER_SECOND = 1
+PER_MINUTE = 60
+PER_HOUR = 60 * 60
+PER_DAY = 60 * 60 * 24
+
+class Limiter(object):
+
+    """Class providing rate limiting of arbitrary actions."""
+
+    def __init__(self, limits):
+        """Create a rate limiter.
+
+        limits: a dict mapping from action name to a tuple.  The tuple contains
+        the number of times the action may be performed, and the time period
+        (in seconds) during which the number must not be exceeded for this
+        action.  Example: dict(reboot=(10, ratelimiting.PER_MINUTE)) would
+        allow 10 'reboot' actions per minute.
+        """
+        self.limits = limits
+        self._levels = {}
+
+    def perform(self, action_name, username='nobody'):
+        """Attempt to perform an action by the given username.
+
+        action_name: the string name of the action to perform.  This must
+        be a key in the limits dict passed to the ctor.
+
+        username: an optional string name of the user performing the action.
+        Each user has her own set of rate limiting counters.  Defaults to
+        'nobody' (so that if you never specify a username when calling
+        perform(), a single set of counters will be used.)
+
+        Return None if the action may proceed.  If the action may not proceed
+        because it has been rate limited, return the float number of seconds
+        until the action would succeed.
+        """
+        # Think of rate limiting as a bucket leaking water at 1cc/second.  The
+        # bucket can hold as many ccs as there are seconds in the rate
+        # limiting period (e.g. 3600 for per-hour ratelimits), and if you can
+        # perform N actions in that time, each action fills the bucket by
+        # 1/Nth of its volume.  You may only perform an action if the bucket
+        # would not overflow.
+        now = time.time()
+        key = '%s:%s' % (username, action_name)
+        last_time_performed, water_level = self._levels.get(key, (now, 0))
+        # The bucket leaks 1cc/second.
+        water_level -= (now - last_time_performed)
+        if water_level < 0:
+            water_level = 0
+        num_allowed_per_period, period_in_secs = self.limits[action_name]
+        # Fill the bucket by 1/Nth its capacity, and hope it doesn't overflow.
+        capacity = period_in_secs
+        new_level = water_level + (capacity * 1.0 / num_allowed_per_period)
+        if new_level > capacity:
+            # Delay this many seconds.
+            return new_level - capacity
+        self._levels[key] = (now, new_level)
+        return None
+
+
+# If one instance of this WSGIApps is unable to handle your load, put a
+# sharding app in front that shards by username to one of many backends.
+
+class WSGIApp(object):
+
+    """Application that tracks rate limits in memory.  Send requests to it of
+    this form:
+
+    POST /limiter/<username>/<urlencoded action>
+
+    and receive a 200 OK, or a 403 Forbidden with an X-Wait-Seconds header
+    containing the number of seconds to wait before the action would succeed.
+    """
+
+    def __init__(self, limiter):
+        """Create the WSGI application using the given Limiter instance."""
+        self.limiter = limiter
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        parts = req.path_info.split('/')
+        # format: /limiter/<username>/<urlencoded action>
+        if req.method != 'POST':
+            raise webob.exc.HTTPMethodNotAllowed()
+        if len(parts) != 4 or parts[1] != 'limiter':
+            raise webob.exc.HTTPNotFound()
+        username = parts[2]
+        action_name = urllib.unquote(parts[3])
+        delay = self.limiter.perform(action_name, username)
+        if delay:
+            return webob.exc.HTTPForbidden(
+                    headers={'X-Wait-Seconds': "%.2f" % delay})
+        else:
+            return '' # 200 OK
+
+
+class WSGIAppProxy(object):
+
+    """Limiter lookalike that proxies to a ratelimiting.WSGIApp."""
+
+    def __init__(self, service_host):
+        """Creates a proxy pointing to a ratelimiting.WSGIApp at the given 
+        host."""
+        self.service_host = service_host
+
+    def perform(self, action, username='nobody'):
+        conn = httplib.HTTPConnection(self.service_host)
+        conn.request('POST', '/limiter/%s/%s' % (username, action))
+        resp = conn.getresponse()
+        if resp.status == 200:
+            return None # no delay
+        return float(resp.getheader('X-Wait-Seconds'))
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
new file mode 100644
index 000000000..f234af7de
--- /dev/null
+++ b/nova/api/openstack/servers.py
@@ -0,0 +1,276 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import time
+
+import webob
+from webob import exc
+
+from nova import flags
+from nova import rpc
+from nova import utils
+from nova import wsgi
+from nova.api import cloud
+from nova.api.openstack import context
+from nova.api.openstack import faults
+from nova.compute import instance_types
+from nova.compute import power_state
+import nova.api.openstack
+import nova.image.service
+
+FLAGS = flags.FLAGS
+
+def _filter_params(inst_dict):
+    """ Extracts all updatable parameters for a server update request """
+    keys = dict(name='name', admin_pass='adminPass')
+    new_attrs = {}
+    for k, v in keys.items():
+        if inst_dict.has_key(v):
+            new_attrs[k] = inst_dict[v]
+    return new_attrs
+
+def _entity_list(entities):
+    """ Coerces a list of servers into proper dictionary format """
+    return dict(servers=entities)
+
+def _entity_detail(inst):
+    """ Maps everything to valid attributes for return"""
+    power_mapping = { 
+        power_state.NOSTATE:  'build', 
+        power_state.RUNNING:  'active',
+        power_state.BLOCKED:  'active',
+        power_state.PAUSED:   'suspended',
+        power_state.SHUTDOWN: 'active',
+        power_state.SHUTOFF:  'active',
+        power_state.CRASHED:  'error'
+    }
+    inst_dict = {}
+
+    mapped_keys = dict(status='state', imageId='image_id', 
+        flavorId='instance_type', name='server_name', id='id')
+
+    for k, v in mapped_keys.iteritems():
+        inst_dict[k] = inst[v]
+
+    inst_dict['status'] = power_mapping[inst_dict['status']]
+    inst_dict['addresses'] = dict(public=[], private=[])
+    inst_dict['metadata'] = {}
+    inst_dict['hostId'] = ''
+
+    return dict(server=inst_dict)
+
+def _entity_inst(inst):
+    """ Filters all model attributes save for id and name """
+    return dict(server=dict(id=inst['id'], name=inst['server_name']))
+
+class Controller(wsgi.Controller):
+    """ The Server API controller for the OpenStack API """
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "server": [ "id", "imageId", "name", "flavorId", "hostId", 
+                            "status", "progress", "progress" ]
+            }
+        }
+    }
+
+    def __init__(self, db_driver=None):
+        if not db_driver:
+            db_driver = FLAGS.db_driver
+        self.db_driver = utils.import_object(db_driver)
+        super(Controller, self).__init__()
+
+    def index(self, req):
+        """ Returns a list of server names and ids for a given user """
+        return self._items(req, entity_maker=_entity_inst)
+
+    def detail(self, req):
+        """ Returns a list of server details for a given user """
+        return self._items(req, entity_maker=_entity_detail)
+
+    def _items(self, req, entity_maker):
+        """Returns a list of servers for a given user.
+
+        entity_maker - either _entity_detail or _entity_inst
+        """
+        user_id = req.environ['nova.context']['user']['id']
+        instance_list = self.db_driver.instance_get_all_by_user(None, user_id)
+        limited_list = nova.api.openstack.limited(instance_list, req)
+        res = [entity_maker(inst)['server'] for inst in limited_list]
+        return _entity_list(res)
+
+    def show(self, req, id):
+        """ Returns server details by server id """
+        user_id = req.environ['nova.context']['user']['id']
+        inst = self.db_driver.instance_get_by_internal_id(None, int(id))
+        if inst:
+            if inst.user_id == user_id:
+                return _entity_detail(inst)
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, id):
+        """ Destroys a server """
+        user_id = req.environ['nova.context']['user']['id']
+        instance = self.db_driver.instance_get_by_internal_id(None, int(id))
+        if instance and instance['user_id'] == user_id:
+            self.db_driver.instance_destroy(None, id)
+            return faults.Fault(exc.HTTPAccepted())
+        return faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req):
+        """ Creates a new server for a given user """
+
+        env = self._deserialize(req.body, req)
+        if not env:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        #try:
+        inst = self._build_server_instance(req, env)
+        #except Exception, e:
+        #    return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        rpc.cast(
+            FLAGS.compute_topic, {
+                "method": "run_instance",
+                "args": {"instance_id": inst['id']}})
+        return _entity_inst(inst)
+
+    def update(self, req, id):
+        """ Updates the server name or password """
+        user_id = req.environ['nova.context']['user']['id']
+
+        inst_dict = self._deserialize(req.body, req)
+        
+        if not inst_dict:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        instance = self.db_driver.instance_get_by_internal_id(None, int(id))
+        if not instance or instance.user_id != user_id:
+            return faults.Fault(exc.HTTPNotFound())
+
+        self.db_driver.instance_update(None, int(id), 
+            _filter_params(inst_dict['server']))
+        return faults.Fault(exc.HTTPNoContent())
+
+    def action(self, req, id):
+        """ multi-purpose method used to reboot, rebuild, and 
+        resize a server """
+	user_id = req.environ['nova.context']['user']['id']
+        input_dict = self._deserialize(req.body, req)
+        try:
+            reboot_type = input_dict['reboot']['type']
+        except Exception:
+            raise faults.Fault(webob.exc.HTTPNotImplemented())
+	inst_ref = self.db.instance_get_by_internal_id(None, int(id))
+	if not inst_ref or (inst_ref and not inst_ref.user_id == user_id):
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        cloud.reboot(id)
+
+    def _build_server_instance(self, req, env):
+        """Build instance data structure and save it to the data store."""
+        ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+        inst = {}
+
+        user_id = req.environ['nova.context']['user']['id']
+
+        flavor_id = env['server']['flavorId']
+
+        instance_type, flavor = [(k, v) for k, v in
+            instance_types.INSTANCE_TYPES.iteritems()
+            if v['flavorid'] == flavor_id][0]
+
+        image_id = env['server']['imageId']
+        
+        img_service = utils.import_object(FLAGS.image_service)
+
+        image = img_service.show(image_id)
+
+        if not image: 
+            raise Exception, "Image not found"
+
+        inst['server_name'] = env['server']['name']
+        inst['image_id'] = image_id
+        inst['user_id'] = user_id
+        inst['launch_time'] = ltime
+        inst['mac_address'] = utils.generate_mac()
+        inst['project_id'] = user_id
+
+        inst['state_description'] = 'scheduling'
+        inst['kernel_id'] = image.get('kernelId', FLAGS.default_kernel)
+        inst['ramdisk_id'] = image.get('ramdiskId', FLAGS.default_ramdisk)
+        inst['reservation_id'] = utils.generate_uid('r')
+
+        inst['display_name'] = env['server']['name']
+        inst['display_description'] = env['server']['name']
+
+        #TODO(dietz) this may be ill advised
+        key_pair_ref = self.db_driver.key_pair_get_all_by_user(
+            None, user_id)[0]
+
+        inst['key_data'] = key_pair_ref['public_key']
+        inst['key_name'] = key_pair_ref['name']
+
+        #TODO(dietz) stolen from ec2 api, see TODO there
+        inst['security_group'] = 'default'
+
+        # Flavor related attributes
+        inst['instance_type'] = instance_type
+        inst['memory_mb'] = flavor['memory_mb']
+        inst['vcpus'] = flavor['vcpus']
+        inst['local_gb'] = flavor['local_gb']
+
+        ref = self.db_driver.instance_create(None, inst)
+        inst['id'] = ref.internal_id
+        
+        # TODO(dietz): this isn't explicitly necessary, but the networking
+        # calls depend on an object with a project_id property, and therefore
+        # should be cleaned up later
+        api_context = context.APIRequestContext(user_id)
+    
+        inst['mac_address'] = utils.generate_mac()
+        
+        #TODO(dietz) is this necessary? 
+        inst['launch_index'] = 0
+
+        inst['hostname'] = str(ref.internal_id)
+        self.db_driver.instance_update(None, inst['id'], inst)
+
+        network_manager = utils.import_object(FLAGS.network_manager)
+        address = network_manager.allocate_fixed_ip(api_context,
+            inst['id'])
+
+        # TODO(vish): This probably should be done in the scheduler
+        #             network is setup when host is assigned
+        network_topic = self._get_network_topic(user_id)
+        rpc.call(network_topic,
+                 {"method": "setup_fixed_ip",
+                  "args": {"context": None,
+                           "address": address}})
+        return inst
+
+    def _get_network_topic(self, user_id):
+        """Retrieves the network host for a project"""
+        network_ref = self.db_driver.project_get_network(None, 
+            user_id)
+        host = network_ref['host']
+        if not host:
+            host = rpc.call(FLAGS.network_topic,
+                                  {"method": "set_network_host",
+                                   "args": {"context": None,
+                                            "project_id": user_id}})
+        return self.db_driver.queue_get_for(None, FLAGS.network_topic, host)
diff --git a/nova/api/openstack/sharedipgroups.py b/nova/api/openstack/sharedipgroups.py
new file mode 100644
index 000000000..4d2d0ede1
--- /dev/null
+++ b/nova/api/openstack/sharedipgroups.py
@@ -0,0 +1,20 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova import wsgi
+
+class Controller(wsgi.Controller): pass
diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
deleted file mode 100644
index 89a4693ad..000000000
--- a/nova/api/rackspace/__init__.py
+++ /dev/null
@@ -1,190 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-WSGI middleware for Rackspace API controllers.
-"""
-
-import json
-import time
-
-import routes
-import webob.dec
-import webob.exc
-import webob
-
-from nova import flags
-from nova import utils
-from nova import wsgi
-from nova.api.rackspace import faults
-from nova.api.rackspace import backup_schedules
-from nova.api.rackspace import flavors
-from nova.api.rackspace import images
-from nova.api.rackspace import ratelimiting
-from nova.api.rackspace import servers
-from nova.api.rackspace import sharedipgroups
-from nova.auth import manager
-
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('nova_api_auth',
-    'nova.api.rackspace.auth.BasicApiAuthManager', 
-    'The auth mechanism to use for the Rackspace API implemenation')
-
-class API(wsgi.Middleware):
-    """WSGI entry point for all Rackspace API requests."""
-
-    def __init__(self):
-        app = AuthMiddleware(RateLimitingMiddleware(APIRouter()))
-        super(API, self).__init__(app)
-
-class AuthMiddleware(wsgi.Middleware):
-    """Authorize the rackspace API request or return an HTTP Forbidden."""
-
-    def __init__(self, application):
-        self.auth_driver = utils.import_class(FLAGS.nova_api_auth)()
-        super(AuthMiddleware, self).__init__(application)
-
-    @webob.dec.wsgify
-    def __call__(self, req):
-        if not req.headers.has_key("X-Auth-Token"):
-            return self.auth_driver.authenticate(req)
-
-        user = self.auth_driver.authorize_token(req.headers["X-Auth-Token"])
-
-        if not user:
-            return faults.Fault(webob.exc.HTTPUnauthorized())
-
-        if not req.environ.has_key('nova.context'):
-            req.environ['nova.context'] = {}
-        req.environ['nova.context']['user'] = user
-        return self.application
-
-class RateLimitingMiddleware(wsgi.Middleware):
-    """Rate limit incoming requests according to the OpenStack rate limits."""
-
-    def __init__(self, application, service_host=None):
-        """Create a rate limiting middleware that wraps the given application.
-
-        By default, rate counters are stored in memory.  If service_host is
-        specified, the middleware instead relies on the ratelimiting.WSGIApp
-        at the given host+port to keep rate counters.
-        """
-        super(RateLimitingMiddleware, self).__init__(application)
-        if not service_host:
-            #TODO(gundlach): These limits were based on limitations of Cloud 
-            #Servers.  We should revisit them in Nova.
-            self.limiter = ratelimiting.Limiter(limits={
-                    'DELETE': (100, ratelimiting.PER_MINUTE),
-                    'PUT': (10, ratelimiting.PER_MINUTE),
-                    'POST': (10, ratelimiting.PER_MINUTE),
-                    'POST servers': (50, ratelimiting.PER_DAY),
-                    'GET changes-since': (3, ratelimiting.PER_MINUTE),
-                })
-        else:
-            self.limiter = ratelimiting.WSGIAppProxy(service_host)
-
-    @webob.dec.wsgify
-    def __call__(self, req):
-        """Rate limit the request.
-        
-        If the request should be rate limited, return a 413 status with a 
-        Retry-After header giving the time when the request would succeed.
-        """
-        username = req.headers['X-Auth-User']
-        action_name = self.get_action_name(req)
-        if not action_name: # not rate limited
-            return self.application
-        delay = self.get_delay(action_name, username)
-        if delay:
-            # TODO(gundlach): Get the retry-after format correct.
-            exc = webob.exc.HTTPRequestEntityTooLarge(
-                    explanation='Too many requests.',
-                    headers={'Retry-After': time.time() + delay})
-            raise faults.Fault(exc)
-        return self.application
-
-    def get_delay(self, action_name, username):
-        """Return the delay for the given action and username, or None if
-        the action would not be rate limited.
-        """
-        if action_name == 'POST servers':
-            # "POST servers" is a POST, so it counts against "POST" too.
-            # Attempt the "POST" first, lest we are rate limited by "POST" but
-            # use up a precious "POST servers" call.
-            delay = self.limiter.perform("POST", username=username)
-            if delay:
-                return delay
-        return self.limiter.perform(action_name, username=username)
-
-    def get_action_name(self, req):
-        """Return the action name for this request."""
-        if req.method == 'GET' and 'changes-since' in req.GET:
-            return 'GET changes-since'
-        if req.method == 'POST' and req.path_info.startswith('/servers'):
-            return 'POST servers'
-        if req.method in ['PUT', 'POST', 'DELETE']:
-            return req.method
-        return None
-
-
-class APIRouter(wsgi.Router):
-    """
-    Routes requests on the Rackspace API to the appropriate controller
-    and method.
-    """
-
-    def __init__(self):
-        mapper = routes.Mapper()
-        mapper.resource("server", "servers", controller=servers.Controller(),
-                        collection={ 'detail': 'GET'},
-                        member={'action':'POST'})
-
-        mapper.resource("backup_schedule", "backup_schedules", 
-                        controller=backup_schedules.Controller(),
-                        parent_resource=dict(member_name='server', 
-                        collection_name = 'servers')) 
-
-        mapper.resource("image", "images", controller=images.Controller(),
-                        collection={'detail': 'GET'})
-        mapper.resource("flavor", "flavors", controller=flavors.Controller(),
-                        collection={'detail': 'GET'})
-        mapper.resource("sharedipgroup", "sharedipgroups",
-                        controller=sharedipgroups.Controller())
-
-        super(APIRouter, self).__init__(mapper)
-
-
-def limited(items, req):
-    """Return a slice of items according to requested offset and limit.
-    
-    items - a sliceable
-    req - wobob.Request possibly containing offset and limit GET variables.
-          offset is where to start in the list, and limit is the maximum number
-          of items to return.
-
-    If limit is not specified, 0, or > 1000, defaults to 1000.
-    """
-    offset = int(req.GET.get('offset', 0))
-    limit = int(req.GET.get('limit', 0))
-    if not limit:
-        limit = 1000
-    limit = min(1000, limit)
-    range_end = offset + limit
-    return items[offset:range_end]
-
diff --git a/nova/api/rackspace/_id_translator.py b/nova/api/rackspace/_id_translator.py
deleted file mode 100644
index 333aa8434..000000000
--- a/nova/api/rackspace/_id_translator.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from nova import datastore
-
-class RackspaceAPIIdTranslator(object):
-    """
-    Converts Rackspace API ids to and from the id format for a given
-    strategy.
-    """
-
-    def __init__(self, id_type, service_name):
-        """
-        Creates a translator for ids of the given type (e.g. 'flavor'), for the
-        given storage service backend class name (e.g. 'LocalFlavorService').
-        """
-
-        self._store = datastore.Redis.instance()
-        key_prefix = "rsapi.idtranslator.%s.%s" % (id_type, service_name)
-        # Forward (strategy format -> RS format) and reverse translation keys
-        self._fwd_key = "%s.fwd" % key_prefix
-        self._rev_key = "%s.rev" % key_prefix
-
-    def to_rs_id(self, opaque_id):
-        """Convert an id from a strategy-specific one to a Rackspace one."""
-        result = self._store.hget(self._fwd_key, str(opaque_id))
-        if result: # we have a mapping from opaque to RS for this strategy
-            return int(result)
-        else:
-            # Store the mapping.
-            nextid = self._store.incr("%s.lastid" % self._fwd_key)
-            if self._store.hsetnx(self._fwd_key, str(opaque_id), nextid):
-                # If someone else didn't beat us to it, store the reverse
-                # mapping as well.
-                self._store.hset(self._rev_key, nextid, str(opaque_id))
-                return nextid
-            else:
-                # Someone beat us to it; use their number instead, and
-                # discard nextid (which is OK -- we don't require that
-                # every int id be used.)
-                return int(self._store.hget(self._fwd_key, str(opaque_id)))
-
-    def from_rs_id(self, rs_id):
-        """Convert a Rackspace id to a strategy-specific one."""
-        return self._store.hget(self._rev_key, rs_id)
diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
deleted file mode 100644
index c45156ebd..000000000
--- a/nova/api/rackspace/auth.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import datetime
-import hashlib
-import json
-import time
-
-import webob.exc
-import webob.dec
-
-from nova import auth
-from nova import db
-from nova import flags
-from nova import manager
-from nova import utils
-from nova.api.rackspace import faults
-
-FLAGS = flags.FLAGS
-
-class Context(object):
-    pass
-
-class BasicApiAuthManager(object):
-    """ Implements a somewhat rudimentary version of Rackspace Auth"""
-
-    def __init__(self, host=None, db_driver=None):
-        if not host:
-            host = FLAGS.host
-        self.host = host                                                                                                                                     
-        if not db_driver:
-            db_driver = FLAGS.db_driver                                                                                                                      
-        self.db = utils.import_object(db_driver)
-        self.auth = auth.manager.AuthManager()
-        self.context = Context()
-        super(BasicApiAuthManager, self).__init__()
-
-    def authenticate(self, req):
-        # Unless the request is explicitly made against /<version>/ don't
-        # honor it
-        path_info = req.path_info
-        if len(path_info) > 1:
-            return faults.Fault(webob.exc.HTTPUnauthorized())
-
-        try:
-            username, key = req.headers['X-Auth-User'], \
-                req.headers['X-Auth-Key']
-        except KeyError:
-            return faults.Fault(webob.exc.HTTPUnauthorized())
-
-        username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
-        token, user = self._authorize_user(username, key)
-        if user and token:
-            res = webob.Response()
-            res.headers['X-Auth-Token'] = token['token_hash']
-            res.headers['X-Server-Management-Url'] = \
-                token['server_management_url']
-            res.headers['X-Storage-Url'] = token['storage_url']
-            res.headers['X-CDN-Management-Url'] = token['cdn_management_url']
-            res.content_type = 'text/plain'
-            res.status = '204'
-            return res
-        else:
-            return faults.Fault(webob.exc.HTTPUnauthorized())
-
-    def authorize_token(self, token_hash):
-        """ retrieves user information from the datastore given a token
-        
-        If the token has expired, returns None
-        If the token is not found, returns None
-        Otherwise returns the token
-
-        This method will also remove the token if the timestamp is older than
-        2 days ago.
-        """
-        token = self.db.auth_get_token(self.context, token_hash) 
-        if token:
-            delta = datetime.datetime.now() - token['created_at']
-            if delta.days >= 2:
-                self.db.auth_destroy_token(self.context, token)
-            else:
-                user = self.auth.get_user(token['user_id'])
-                return { 'id':user['uid'] }
-        return None
-
-    def _authorize_user(self, username, key):
-        """ Generates a new token and assigns it to a user """
-        user = self.auth.get_user_from_access_key(key)
-        if user and user['name'] == username:
-            token_hash = hashlib.sha1('%s%s%f' % (username, key,
-                time.time())).hexdigest()
-            token = {}
-            token['token_hash'] = token_hash
-            token['cdn_management_url'] = ''
-            token['server_management_url'] = self._get_server_mgmt_url()
-            token['storage_url'] = ''
-            token['user_id'] = user['uid']
-            self.db.auth_create_token(self.context, token)
-            return token, user
-        return None, None 
-
-    def _get_server_mgmt_url(self):
-        return 'https://%s/v1.0/' % self.host
-        
diff --git a/nova/api/rackspace/backup_schedules.py b/nova/api/rackspace/backup_schedules.py
deleted file mode 100644
index 9c0d41fa0..000000000
--- a/nova/api/rackspace/backup_schedules.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-from webob import exc
-
-from nova import wsgi
-from nova.api.rackspace import faults
-import nova.image.service
-
-class Controller(wsgi.Controller):
-    def __init__(self):
-        pass
-
-    def index(self, req, server_id):
-        return faults.Fault(exc.HTTPNotFound())
-
-    def create(self, req, server_id):
-        """ No actual update method required, since the existing API allows
-        both create and update through a POST """
-        return faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, server_id):
-        return faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/rackspace/context.py b/nova/api/rackspace/context.py
deleted file mode 100644
index 77394615b..000000000
--- a/nova/api/rackspace/context.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-APIRequestContext
-"""
-
-import random
-
-class Project(object):
-    def __init__(self, user_id):
-        self.id = user_id
-    
-class APIRequestContext(object):
-    """ This is an adapter class to get around all of the assumptions made in
-    the FlatNetworking """
-    def __init__(self, user_id):
-        self.user_id = user_id
-        self.project = Project(user_id)
diff --git a/nova/api/rackspace/faults.py b/nova/api/rackspace/faults.py
deleted file mode 100644
index 32e5c866f..000000000
--- a/nova/api/rackspace/faults.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-
-import webob.dec
-import webob.exc
-
-from nova import wsgi
-
-
-class Fault(webob.exc.HTTPException):
-
-    """An RS API fault response."""
-
-    _fault_names = {
-            400: "badRequest",
-            401: "unauthorized",
-            403: "resizeNotAllowed",
-            404: "itemNotFound",
-            405: "badMethod",
-            409: "inProgress",
-            413: "overLimit",
-            415: "badMediaType",
-            501: "notImplemented",
-            503: "serviceUnavailable"}
-
-    def __init__(self, exception):
-        """Create a Fault for the given webob.exc.exception."""
-        self.wrapped_exc = exception
-
-    @webob.dec.wsgify
-    def __call__(self, req):
-        """Generate a WSGI response based on the exception passed to ctor."""
-        # Replace the body with fault details.
-        code = self.wrapped_exc.status_int
-        fault_name = self._fault_names.get(code, "cloudServersFault")
-        fault_data = {
-            fault_name: {
-                'code': code,
-                'message': self.wrapped_exc.explanation}}
-        if code == 413:
-            retry = self.wrapped_exc.headers['Retry-After']
-            fault_data[fault_name]['retryAfter'] = retry
-        # 'code' is an attribute on the fault tag itself 
-        metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
-        serializer = wsgi.Serializer(req.environ, metadata)
-        self.wrapped_exc.body = serializer.to_content_type(fault_data)
-        return self.wrapped_exc
diff --git a/nova/api/rackspace/flavors.py b/nova/api/rackspace/flavors.py
deleted file mode 100644
index 916449854..000000000
--- a/nova/api/rackspace/flavors.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from webob import exc
-
-from nova.api.rackspace import faults
-from nova.compute import instance_types
-from nova import wsgi
-import nova.api.rackspace
-
-class Controller(wsgi.Controller):
-    """Flavor controller for the Rackspace API."""
-
-    _serialization_metadata = {
-        'application/xml': {
-            "attributes": {
-                "flavor": [ "id", "name", "ram", "disk" ]
-            }
-        }
-    }
-
-    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']])
-
-    def detail(self, req):
-        """Return all flavors in detail."""
-        items = [self.show(req, id)['flavor'] for id in self._all_ids()]
-        items = nova.api.rackspace.limited(items, req)
-        return dict(flavors=items)
-
-    def show(self, req, id):
-        """Return data about the given flavor id."""
-        for name, val in instance_types.INSTANCE_TYPES.iteritems():
-            if val['flavorid'] == int(id):
-                item = dict(ram=val['memory_mb'], disk=val['local_gb'],
-                            id=val['flavorid'], name=name)
-                return dict(flavor=item)
-        raise faults.Fault(exc.HTTPNotFound())
-
-    def _all_ids(self):
-        """Return the list of all flavorids."""
-        return [i['flavorid'] for i in instance_types.INSTANCE_TYPES.values()]
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
deleted file mode 100644
index 82dcd2049..000000000
--- a/nova/api/rackspace/images.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from webob import exc
-
-from nova import flags
-from nova import utils
-from nova import wsgi
-import nova.api.rackspace
-import nova.image.service
-from nova.api.rackspace import faults
-
-
-FLAGS = flags.FLAGS
-
-class Controller(wsgi.Controller):
-
-    _serialization_metadata = {
-        'application/xml': {
-            "attributes": {
-                "image": [ "id", "name", "updated", "created", "status",
-                           "serverId", "progress" ]
-            }
-        }
-    }
-
-    def __init__(self):
-        self._service = utils.import_object(FLAGS.image_service)
-
-    def index(self, req):
-        """Return all public images in brief."""
-        return dict(images=[dict(id=img['id'], name=img['name'])
-                            for img in self.detail(req)['images']])
-
-    def detail(self, req):
-        """Return all public images in detail."""
-        data = self._service.index()
-        data = nova.api.rackspace.limited(data, req)
-        return dict(images=data)
-
-    def show(self, req, id):
-        """Return data about the given image id."""
-        return dict(image=self._service.show(id))
-
-    def delete(self, req, id):
-        # Only public images are supported for now.
-        raise faults.Fault(exc.HTTPNotFound())
-
-    def create(self, req):
-        # Only public images are supported for now, so a request to
-        # make a backup of a server cannot be supproted.
-        raise faults.Fault(exc.HTTPNotFound())
-
-    def update(self, req, id):
-        # Users may not modify public images, and that's all that 
-        # we support for now.
-        raise faults.Fault(exc.HTTPNotFound())
diff --git a/nova/api/rackspace/notes.txt b/nova/api/rackspace/notes.txt
deleted file mode 100644
index e133bf5ea..000000000
--- a/nova/api/rackspace/notes.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-We will need:
-
-ImageService
-a service that can do crud on image information.  not user-specific. opaque
-image ids.
-
-GlanceImageService(ImageService):
-image ids are URIs.
-
-LocalImageService(ImageService):
-image ids are random strings.
-
-RackspaceAPITranslationStore:
-translates RS server/images/flavor/etc ids into formats required
-by a given ImageService strategy.
-
-api.rackspace.images.Controller:
-uses an ImageService strategy behind the scenes to do its fetching; it just
-converts int image id into a strategy-specific image id.
-
-who maintains the mapping from user to [images he owns]?  nobody, because
-we have no way of enforcing access to his images, without kryptex which
-won't be in Austin.
diff --git a/nova/api/rackspace/ratelimiting/__init__.py b/nova/api/rackspace/ratelimiting/__init__.py
deleted file mode 100644
index f843bac0f..000000000
--- a/nova/api/rackspace/ratelimiting/__init__.py
+++ /dev/null
@@ -1,122 +0,0 @@
-"""Rate limiting of arbitrary actions."""
-
-import httplib
-import time
-import urllib
-import webob.dec
-import webob.exc
-
-
-# Convenience constants for the limits dictionary passed to Limiter().
-PER_SECOND = 1
-PER_MINUTE = 60
-PER_HOUR = 60 * 60
-PER_DAY = 60 * 60 * 24
-
-class Limiter(object):
-
-    """Class providing rate limiting of arbitrary actions."""
-
-    def __init__(self, limits):
-        """Create a rate limiter.
-
-        limits: a dict mapping from action name to a tuple.  The tuple contains
-        the number of times the action may be performed, and the time period
-        (in seconds) during which the number must not be exceeded for this
-        action.  Example: dict(reboot=(10, ratelimiting.PER_MINUTE)) would
-        allow 10 'reboot' actions per minute.
-        """
-        self.limits = limits
-        self._levels = {}
-
-    def perform(self, action_name, username='nobody'):
-        """Attempt to perform an action by the given username.
-
-        action_name: the string name of the action to perform.  This must
-        be a key in the limits dict passed to the ctor.
-
-        username: an optional string name of the user performing the action.
-        Each user has her own set of rate limiting counters.  Defaults to
-        'nobody' (so that if you never specify a username when calling
-        perform(), a single set of counters will be used.)
-
-        Return None if the action may proceed.  If the action may not proceed
-        because it has been rate limited, return the float number of seconds
-        until the action would succeed.
-        """
-        # Think of rate limiting as a bucket leaking water at 1cc/second.  The
-        # bucket can hold as many ccs as there are seconds in the rate
-        # limiting period (e.g. 3600 for per-hour ratelimits), and if you can
-        # perform N actions in that time, each action fills the bucket by
-        # 1/Nth of its volume.  You may only perform an action if the bucket
-        # would not overflow.
-        now = time.time()
-        key = '%s:%s' % (username, action_name)
-        last_time_performed, water_level = self._levels.get(key, (now, 0))
-        # The bucket leaks 1cc/second.
-        water_level -= (now - last_time_performed)
-        if water_level < 0:
-            water_level = 0
-        num_allowed_per_period, period_in_secs = self.limits[action_name]
-        # Fill the bucket by 1/Nth its capacity, and hope it doesn't overflow.
-        capacity = period_in_secs
-        new_level = water_level + (capacity * 1.0 / num_allowed_per_period)
-        if new_level > capacity:
-            # Delay this many seconds.
-            return new_level - capacity
-        self._levels[key] = (now, new_level)
-        return None
-
-
-# If one instance of this WSGIApps is unable to handle your load, put a
-# sharding app in front that shards by username to one of many backends.
-
-class WSGIApp(object):
-
-    """Application that tracks rate limits in memory.  Send requests to it of
-    this form:
-
-    POST /limiter/<username>/<urlencoded action>
-
-    and receive a 200 OK, or a 403 Forbidden with an X-Wait-Seconds header
-    containing the number of seconds to wait before the action would succeed.
-    """
-
-    def __init__(self, limiter):
-        """Create the WSGI application using the given Limiter instance."""
-        self.limiter = limiter
-
-    @webob.dec.wsgify
-    def __call__(self, req):
-        parts = req.path_info.split('/')
-        # format: /limiter/<username>/<urlencoded action>
-        if req.method != 'POST':
-            raise webob.exc.HTTPMethodNotAllowed()
-        if len(parts) != 4 or parts[1] != 'limiter':
-            raise webob.exc.HTTPNotFound()
-        username = parts[2]
-        action_name = urllib.unquote(parts[3])
-        delay = self.limiter.perform(action_name, username)
-        if delay:
-            return webob.exc.HTTPForbidden(
-                    headers={'X-Wait-Seconds': "%.2f" % delay})
-        else:
-            return '' # 200 OK
-
-
-class WSGIAppProxy(object):
-
-    """Limiter lookalike that proxies to a ratelimiting.WSGIApp."""
-
-    def __init__(self, service_host):
-        """Creates a proxy pointing to a ratelimiting.WSGIApp at the given 
-        host."""
-        self.service_host = service_host
-
-    def perform(self, action, username='nobody'):
-        conn = httplib.HTTPConnection(self.service_host)
-        conn.request('POST', '/limiter/%s/%s' % (username, action))
-        resp = conn.getresponse()
-        if resp.status == 200:
-            return None # no delay
-        return float(resp.getheader('X-Wait-Seconds'))
diff --git a/nova/api/rackspace/ratelimiting/tests.py b/nova/api/rackspace/ratelimiting/tests.py
deleted file mode 100644
index 4c9510917..000000000
--- a/nova/api/rackspace/ratelimiting/tests.py
+++ /dev/null
@@ -1,237 +0,0 @@
-import httplib
-import StringIO
-import time
-import unittest
-import webob
-
-import nova.api.rackspace.ratelimiting as ratelimiting
-
-class LimiterTest(unittest.TestCase):
-
-    def setUp(self):
-        self.limits = {
-                'a': (5, ratelimiting.PER_SECOND),
-                'b': (5, ratelimiting.PER_MINUTE),
-                'c': (5, ratelimiting.PER_HOUR),
-                'd': (1, ratelimiting.PER_SECOND),
-                'e': (100, ratelimiting.PER_SECOND)}
-        self.rl = ratelimiting.Limiter(self.limits)
-
-    def exhaust(self, action, times_until_exhausted, **kwargs):
-        for i in range(times_until_exhausted):
-            when = self.rl.perform(action, **kwargs)
-            self.assertEqual(when, None)
-        num, period = self.limits[action]
-        delay = period * 1.0 / num
-        # Verify that we are now thoroughly delayed
-        for i in range(10):
-            when = self.rl.perform(action, **kwargs)
-            self.assertAlmostEqual(when, delay, 2)
-
-    def test_second(self):
-        self.exhaust('a', 5)
-        time.sleep(0.2)
-        self.exhaust('a', 1)
-        time.sleep(1)
-        self.exhaust('a', 5)
-
-    def test_minute(self):
-        self.exhaust('b', 5)
-
-    def test_one_per_period(self):
-        def allow_once_and_deny_once():
-            when = self.rl.perform('d')
-            self.assertEqual(when, None)
-            when = self.rl.perform('d')
-            self.assertAlmostEqual(when, 1, 2)
-            return when
-        time.sleep(allow_once_and_deny_once())
-        time.sleep(allow_once_and_deny_once())
-        allow_once_and_deny_once()
-
-    def test_we_can_go_indefinitely_if_we_spread_out_requests(self):
-        for i in range(200):
-            when = self.rl.perform('e')
-            self.assertEqual(when, None)
-            time.sleep(0.01)
-
-    def test_users_get_separate_buckets(self):
-        self.exhaust('c', 5, username='alice')
-        self.exhaust('c', 5, username='bob')
-        self.exhaust('c', 5, username='chuck')
-        self.exhaust('c', 0, username='chuck')
-        self.exhaust('c', 0, username='bob')
-        self.exhaust('c', 0, username='alice')
-
-
-class FakeLimiter(object):
-    """Fake Limiter class that you can tell how to behave."""
-    def __init__(self, test):
-        self._action = self._username = self._delay = None
-        self.test = test
-    def mock(self, action, username, delay):
-        self._action = action
-        self._username = username
-        self._delay = delay
-    def perform(self, action, username):
-        self.test.assertEqual(action, self._action)
-        self.test.assertEqual(username, self._username)
-        return self._delay
-
-
-class WSGIAppTest(unittest.TestCase):
-
-    def setUp(self):
-        self.limiter = FakeLimiter(self)
-        self.app = ratelimiting.WSGIApp(self.limiter)
-
-    def test_invalid_methods(self):
-        requests = []
-        for method in ['GET', 'PUT', 'DELETE']:
-            req = webob.Request.blank('/limits/michael/breakdance', 
-                                      dict(REQUEST_METHOD=method))
-            requests.append(req)
-        for req in requests:
-            self.assertEqual(req.get_response(self.app).status_int, 405)
-
-    def test_invalid_urls(self):
-        requests = []
-        for prefix in ['limit', '', 'limiter2', 'limiter/limits', 'limiter/1']:
-            req = webob.Request.blank('/%s/michael/breakdance' % prefix,
-                                      dict(REQUEST_METHOD='POST'))
-        requests.append(req)
-        for req in requests:
-            self.assertEqual(req.get_response(self.app).status_int, 404)
-
-    def verify(self, url, username, action, delay=None):
-        """Make sure that POSTing to the given url causes the given username
-        to perform the given action.  Make the internal rate limiter return
-        delay and make sure that the WSGI app returns the correct response.
-        """
-        req = webob.Request.blank(url, dict(REQUEST_METHOD='POST'))
-        self.limiter.mock(action, username, delay)
-        resp = req.get_response(self.app)
-        if not delay:
-            self.assertEqual(resp.status_int, 200)
-        else:
-            self.assertEqual(resp.status_int, 403)
-            self.assertEqual(resp.headers['X-Wait-Seconds'], "%.2f" % delay)
-
-    def test_good_urls(self):
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot')
-
-    def test_escaping(self):
-        self.verify('/limiter/michael/jump%20up', 'michael', 'jump up')
-
-    def test_response_to_delays(self):
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1)
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1.56)
-        self.verify('/limiter/michael/hoot', 'michael', 'hoot', 1000)
-
-
-class FakeHttplibSocket(object):
-    """a fake socket implementation for httplib.HTTPResponse, trivial"""
-
-    def __init__(self, response_string):
-        self._buffer = StringIO.StringIO(response_string)
-
-    def makefile(self, _mode, _other):
-        """Returns the socket's internal buffer"""
-        return self._buffer
-
-
-class FakeHttplibConnection(object):
-    """A fake httplib.HTTPConnection
-
-    Requests made via this connection actually get translated and routed into
-    our WSGI app, we then wait for the response and turn it back into
-    an httplib.HTTPResponse.
-    """
-    def __init__(self, app, host, is_secure=False):
-        self.app = app
-        self.host = host
-
-    def request(self, method, path, data='', headers={}):
-        req = webob.Request.blank(path)
-        req.method = method
-        req.body = data
-        req.headers = headers
-        req.host = self.host
-        # Call the WSGI app, get the HTTP response
-        resp = str(req.get_response(self.app))
-        # For some reason, the response doesn't have "HTTP/1.0 " prepended; I
-        # guess that's a function the web server usually provides.
-        resp = "HTTP/1.0 %s" % resp
-        sock = FakeHttplibSocket(resp)
-        self.http_response = httplib.HTTPResponse(sock)
-        self.http_response.begin()
-
-    def getresponse(self):
-        return self.http_response
-
-
-def wire_HTTPConnection_to_WSGI(host, app):
-    """Monkeypatches HTTPConnection so that if you try to connect to host, you
-    are instead routed straight to the given WSGI app.
-
-    After calling this method, when any code calls
-
-    httplib.HTTPConnection(host)
-
-    the connection object will be a fake.  Its requests will be sent directly
-    to the given WSGI app rather than through a socket.
-    
-    Code connecting to hosts other than host will not be affected.
-
-    This method may be called multiple times to map different hosts to
-    different apps.
-    """
-    class HTTPConnectionDecorator(object):
-        """Wraps the real HTTPConnection class so that when you instantiate
-        the class you might instead get a fake instance."""
-        def __init__(self, wrapped):
-            self.wrapped = wrapped
-        def __call__(self, connection_host, *args, **kwargs):
-            if connection_host == host:
-                return FakeHttplibConnection(app, host)
-            else:
-                return self.wrapped(connection_host, *args, **kwargs)
-    httplib.HTTPConnection = HTTPConnectionDecorator(httplib.HTTPConnection)
-
-
-class WSGIAppProxyTest(unittest.TestCase):
-
-    def setUp(self):
-        """Our WSGIAppProxy is going to call across an HTTPConnection to a
-        WSGIApp running a limiter.  The proxy will send input, and the proxy
-        should receive that same input, pass it to the limiter who gives a
-        result, and send the expected result back.
-
-        The HTTPConnection isn't real -- it's monkeypatched to point straight
-        at the WSGIApp.  And the limiter isn't real -- it's a fake that
-        behaves the way we tell it to.
-        """
-        self.limiter = FakeLimiter(self)
-        app = ratelimiting.WSGIApp(self.limiter)
-        wire_HTTPConnection_to_WSGI('100.100.100.100:80', app)
-        self.proxy = ratelimiting.WSGIAppProxy('100.100.100.100:80')
-
-    def test_200(self):
-        self.limiter.mock('conquer', 'caesar', None)
-        when = self.proxy.perform('conquer', 'caesar')
-        self.assertEqual(when, None)
-
-    def test_403(self):
-        self.limiter.mock('grumble', 'proletariat', 1.5)
-        when = self.proxy.perform('grumble', 'proletariat')
-        self.assertEqual(when, 1.5)
-
-    def test_failure(self):
-        def shouldRaise():
-            self.limiter.mock('murder', 'brutus', None)
-            self.proxy.perform('stab', 'brutus')
-        self.assertRaises(AssertionError, shouldRaise)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
deleted file mode 100644
index 8c489ed83..000000000
--- a/nova/api/rackspace/servers.py
+++ /dev/null
@@ -1,283 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-
-import webob
-from webob import exc
-
-from nova import flags
-from nova import rpc
-from nova import utils
-from nova import wsgi
-from nova.api import cloud
-from nova.api.rackspace import context
-from nova.api.rackspace import faults
-from nova.compute import instance_types
-from nova.compute import power_state
-import nova.api.rackspace
-import nova.image.service
-
-FLAGS = flags.FLAGS
-
-def _image_service():
-    """ Helper method for initializing the image id translator """
-    service = utils.import_object(FLAGS.image_service)
-    return (service, _id_translator.RackspaceAPIIdTranslator(
-            "image", service.__class__.__name__))
-
-def _filter_params(inst_dict):
-    """ Extracts all updatable parameters for a server update request """
-    keys = dict(name='name', admin_pass='adminPass')
-    new_attrs = {}
-    for k, v in keys.items():
-        if inst_dict.has_key(v):
-            new_attrs[k] = inst_dict[v]
-    return new_attrs
-
-def _entity_list(entities):
-    """ Coerces a list of servers into proper dictionary format """
-    return dict(servers=entities)
-
-def _entity_detail(inst):
-    """ Maps everything to Rackspace-like attributes for return"""
-    power_mapping = { 
-        power_state.NOSTATE:  'build', 
-        power_state.RUNNING:  'active',
-        power_state.BLOCKED:  'active',
-        power_state.PAUSED:   'suspended',
-        power_state.SHUTDOWN: 'active',
-        power_state.SHUTOFF:  'active',
-        power_state.CRASHED:  'error'
-    }
-    inst_dict = {}
-
-    mapped_keys = dict(status='state', imageId='image_id', 
-        flavorId='instance_type', name='server_name', id='id')
-
-    for k, v in mapped_keys.iteritems():
-        inst_dict[k] = inst[v]
-
-    inst_dict['status'] = power_mapping[inst_dict['status']]
-    inst_dict['addresses'] = dict(public=[], private=[])
-    inst_dict['metadata'] = {}
-    inst_dict['hostId'] = ''
-
-    return dict(server=inst_dict)
-
-def _entity_inst(inst):
-    """ Filters all model attributes save for id and name """
-    return dict(server=dict(id=inst['id'], name=inst['server_name']))
-
-class Controller(wsgi.Controller):
-    """ The Server API controller for the Openstack API """
-
-    _serialization_metadata = {
-        'application/xml': {
-            "attributes": {
-                "server": [ "id", "imageId", "name", "flavorId", "hostId", 
-                            "status", "progress", "progress" ]
-            }
-        }
-    }
-
-    def __init__(self, db_driver=None):
-        if not db_driver:
-            db_driver = FLAGS.db_driver
-        self.db_driver = utils.import_object(db_driver)
-        super(Controller, self).__init__()
-
-    def index(self, req):
-        """ Returns a list of server names and ids for a given user """
-        return self._items(req, entity_maker=_entity_inst)
-
-    def detail(self, req):
-        """ Returns a list of server details for a given user """
-        return self._items(req, entity_maker=_entity_detail)
-
-    def _items(self, req, entity_maker):
-        """Returns a list of servers for a given user.
-
-        entity_maker - either _entity_detail or _entity_inst
-        """
-        user_id = req.environ['nova.context']['user']['id']
-        instance_list = self.db_driver.instance_get_all_by_user(None, user_id)
-        limited_list = nova.api.rackspace.limited(instance_list, req)
-        res = [entity_maker(inst)['server'] for inst in limited_list]
-        return _entity_list(res)
-
-    def show(self, req, id):
-        """ Returns server details by server id """
-        user_id = req.environ['nova.context']['user']['id']
-        inst = self.db_driver.instance_get_by_internal_id(None, int(id))
-        if inst:
-            if inst.user_id == user_id:
-                return _entity_detail(inst)
-        raise faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, id):
-        """ Destroys a server """
-        user_id = req.environ['nova.context']['user']['id']
-        instance = self.db_driver.instance_get_by_internal_id(None, int(id))
-        if instance and instance['user_id'] == user_id:
-            self.db_driver.instance_destroy(None, id)
-            return faults.Fault(exc.HTTPAccepted())
-        return faults.Fault(exc.HTTPNotFound())
-
-    def create(self, req):
-        """ Creates a new server for a given user """
-
-        env = self._deserialize(req.body, req)
-        if not env:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-
-        #try:
-        inst = self._build_server_instance(req, env)
-        #except Exception, e:
-        #    return faults.Fault(exc.HTTPUnprocessableEntity())
-
-        rpc.cast(
-            FLAGS.compute_topic, {
-                "method": "run_instance",
-                "args": {"instance_id": inst['id']}})
-        return _entity_inst(inst)
-
-    def update(self, req, id):
-        """ Updates the server name or password """
-        user_id = req.environ['nova.context']['user']['id']
-
-        inst_dict = self._deserialize(req.body, req)
-        
-        if not inst_dict:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-
-        instance = self.db_driver.instance_get_by_internal_id(None, int(id))
-        if not instance or instance.user_id != user_id:
-            return faults.Fault(exc.HTTPNotFound())
-
-        self.db_driver.instance_update(None, int(id), 
-            _filter_params(inst_dict['server']))
-        return faults.Fault(exc.HTTPNoContent())
-
-    def action(self, req, id):
-        """ multi-purpose method used to reboot, rebuild, and 
-        resize a server """
-	user_id = req.environ['nova.context']['user']['id']
-        input_dict = self._deserialize(req.body, req)
-        try:
-            reboot_type = input_dict['reboot']['type']
-        except Exception:
-            raise faults.Fault(webob.exc.HTTPNotImplemented())
-	inst_ref = self.db.instance_get_by_internal_id(None, int(id))
-	if not inst_ref or (inst_ref and not inst_ref.user_id == user_id):
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        cloud.reboot(id)
-
-    def _build_server_instance(self, req, env):
-        """Build instance data structure and save it to the data store."""
-        ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
-        inst = {}
-
-        user_id = req.environ['nova.context']['user']['id']
-
-        flavor_id = env['server']['flavorId']
-
-        instance_type, flavor = [(k, v) for k, v in
-            instance_types.INSTANCE_TYPES.iteritems()
-            if v['flavorid'] == flavor_id][0]
-
-        image_id = env['server']['imageId']
-        
-        img_service, image_id_trans = _image_service()
-
-        opaque_image_id = image_id_trans.to_rs_id(image_id)        
-        image = img_service.show(opaque_image_id)
-
-        if not image: 
-            raise Exception, "Image not found"
-
-        inst['server_name'] = env['server']['name']
-        inst['image_id'] = opaque_image_id
-        inst['user_id'] = user_id
-        inst['launch_time'] = ltime
-        inst['mac_address'] = utils.generate_mac()
-        inst['project_id'] = user_id
-
-        inst['state_description'] = 'scheduling'
-        inst['kernel_id'] = image.get('kernelId', FLAGS.default_kernel)
-        inst['ramdisk_id'] = image.get('ramdiskId', FLAGS.default_ramdisk)
-        inst['reservation_id'] = utils.generate_uid('r')
-
-        inst['display_name'] = env['server']['name']
-        inst['display_description'] = env['server']['name']
-
-        #TODO(dietz) this may be ill advised
-        key_pair_ref = self.db_driver.key_pair_get_all_by_user(
-            None, user_id)[0]
-
-        inst['key_data'] = key_pair_ref['public_key']
-        inst['key_name'] = key_pair_ref['name']
-
-        #TODO(dietz) stolen from ec2 api, see TODO there
-        inst['security_group'] = 'default'
-
-        # Flavor related attributes
-        inst['instance_type'] = instance_type
-        inst['memory_mb'] = flavor['memory_mb']
-        inst['vcpus'] = flavor['vcpus']
-        inst['local_gb'] = flavor['local_gb']
-
-        ref = self.db_driver.instance_create(None, inst)
-        inst['id'] = ref.internal_id
-        
-        # TODO(dietz): this isn't explicitly necessary, but the networking
-        # calls depend on an object with a project_id property, and therefore
-        # should be cleaned up later
-        api_context = context.APIRequestContext(user_id)
-    
-        inst['mac_address'] = utils.generate_mac()
-        
-        #TODO(dietz) is this necessary? 
-        inst['launch_index'] = 0
-
-        inst['hostname'] = str(ref.internal_id)
-        self.db_driver.instance_update(None, inst['id'], inst)
-
-        network_manager = utils.import_object(FLAGS.network_manager)
-        address = network_manager.allocate_fixed_ip(api_context,
-            inst['id'])
-
-        # TODO(vish): This probably should be done in the scheduler
-        #             network is setup when host is assigned
-        network_topic = self._get_network_topic(user_id)
-        rpc.call(network_topic,
-                 {"method": "setup_fixed_ip",
-                  "args": {"context": None,
-                           "address": address}})
-        return inst
-
-    def _get_network_topic(self, user_id):
-        """Retrieves the network host for a project"""
-        network_ref = self.db_driver.project_get_network(None, 
-            user_id)
-        host = network_ref['host']
-        if not host:
-            host = rpc.call(FLAGS.network_topic,
-                                  {"method": "set_network_host",
-                                   "args": {"context": None,
-                                            "project_id": user_id}})
-        return self.db_driver.queue_get_for(None, FLAGS.network_topic, host)
diff --git a/nova/api/rackspace/sharedipgroups.py b/nova/api/rackspace/sharedipgroups.py
deleted file mode 100644
index 4d2d0ede1..000000000
--- a/nova/api/rackspace/sharedipgroups.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from nova import wsgi
-
-class Controller(wsgi.Controller): pass
-- 
cgit 


From c1190d55e130a80ac831ce15e6e30c28c5621aff Mon Sep 17 00:00:00 2001
From: mdietz <mdietz@openstack>
Date: Fri, 8 Oct 2010 21:08:48 +0000
Subject: That's what I get for not using a good vimrc

---
 nova/api/openstack/servers.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index f234af7de..5d1ed9822 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -170,14 +170,14 @@ class Controller(wsgi.Controller):
     def action(self, req, id):
         """ multi-purpose method used to reboot, rebuild, and 
         resize a server """
-	user_id = req.environ['nova.context']['user']['id']
+        user_id = req.environ['nova.context']['user']['id']
         input_dict = self._deserialize(req.body, req)
         try:
             reboot_type = input_dict['reboot']['type']
         except Exception:
             raise faults.Fault(webob.exc.HTTPNotImplemented())
-	inst_ref = self.db.instance_get_by_internal_id(None, int(id))
-	if not inst_ref or (inst_ref and not inst_ref.user_id == user_id):
+        inst_ref = self.db.instance_get_by_internal_id(None, int(id))
+        if not inst_ref or (inst_ref and not inst_ref.user_id == user_id):
             return faults.Fault(exc.HTTPUnprocessableEntity())
         cloud.reboot(id)
 
-- 
cgit 


From f447e1a3a2234e0ab3a5e281442659626f8d99bd Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Mon, 11 Oct 2010 13:39:33 +0200
Subject: Rename ec2 get_console_output's instance ID argument to
 'instance_id'. It's passed as a kwarg, based on key in the http query, so it
 must be named this way.

---
 nova/api/ec2/cloud.py  | 6 +++---
 nova/api/ec2/images.py | 3 +++
 2 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 175bb493c..11e54d2b5 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -258,9 +258,9 @@ class CloudController(object):
     def delete_security_group(self, context, group_name, **kwargs):
         return True
 
-    def get_console_output(self, context, ec2_id_list, **kwargs):
-        # ec2_id_list is passed in as a list of instances
-        ec2_id = ec2_id_list[0]
+    def get_console_output(self, context, instance_id, **kwargs):
+        # instance_id is passed in as a list of instances
+        ec2_id = instance_id[0]
         internal_id = ec2_id_to_internal_id(ec2_id)
         instance_ref = db.instance_get_by_internal_id(context, internal_id)
         return rpc.call('%s.%s' % (FLAGS.compute_topic,
diff --git a/nova/api/ec2/images.py b/nova/api/ec2/images.py
index cb54cdda2..f0a43dad6 100644
--- a/nova/api/ec2/images.py
+++ b/nova/api/ec2/images.py
@@ -69,6 +69,9 @@ def list(context, filter_list=[]):
 
     optionally filtered by a list of image_id """
 
+    if FLAGS.connection_type == 'fake':
+        return [{ 'imageId' : 'bar'}]
+
     # FIXME: send along the list of only_images to check for
     response = conn(context).make_request(
             method='GET',
-- 
cgit 


From 76a76244ccee2502903a67f3f17dda97664e6687 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 11 Oct 2010 11:21:26 -0400
Subject: Fix bug 658444

---
 nova/api/ec2/cloud.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 175bb493c..ca0f64e99 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -659,7 +659,12 @@ class CloudController(object):
         return self._format_run_instances(context, reservation_id)
 
 
-    def terminate_instances(self, context, ec2_id_list, **kwargs):
+    def terminate_instances(self, context, instance_id, **kwargs):
+        """Terminate each instance in instance_id, which is a list of ec2 ids.
+
+        instance_id is a kwarg so its name cannot be modified.
+        """
+        ec2_id_list = instance_id
         logging.debug("Going to start terminating instances")
         for id_str in ec2_id_list:
             internal_id = ec2_id_to_internal_id(id_str)
-- 
cgit 


From f9b2f70f22bdc8a9cf08ada5f7ec45eea6060866 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Mon, 11 Oct 2010 11:43:58 -0400
Subject: Rename rsapi to osapi, and make the default subdomain for OpenStack
 API calls be 'api' instead of 'rs'.

---
 nova/api/__init__.py | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 627883018..8ec7094d7 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -31,12 +31,12 @@ from nova.api import openstack
 from nova.api.ec2 import metadatarequesthandler
 
 
-flags.DEFINE_string('rsapi_subdomain', 'rs', 
-                    'subdomain running the RS API')
+flags.DEFINE_string('osapi_subdomain', 'api', 
+                    'subdomain running the OpenStack API')
 flags.DEFINE_string('ec2api_subdomain', 'ec2', 
                     'subdomain running the EC2 API')
 flags.DEFINE_string('FAKE_subdomain', None, 
-                    'set to rs or ec2 to fake the subdomain of the host for testing')
+                    'set to api or ec2 to fake the subdomain of the host for testing')
 FLAGS = flags.FLAGS
 
 
@@ -44,21 +44,21 @@ class API(wsgi.Router):
     """Routes top-level requests to the appropriate controller."""
 
     def __init__(self):
-        rsdomain =  {'sub_domain': [FLAGS.rsapi_subdomain]}
+        osapidomain =  {'sub_domain': [FLAGS.osapi_subdomain]}
         ec2domain = {'sub_domain': [FLAGS.ec2api_subdomain]}
-        # If someone wants to pretend they're hitting the RS subdomain
-        # on their local box, they can set FAKE_subdomain to 'rs', which
-        # removes subdomain restrictions from the RS routes below.
-        if FLAGS.FAKE_subdomain == 'rs':
-            rsdomain = {}
+        # If someone wants to pretend they're hitting the OSAPI subdomain
+        # on their local box, they can set FAKE_subdomain to 'api', which
+        # removes subdomain restrictions from the OpenStack API routes below.
+        if FLAGS.FAKE_subdomain == 'api':
+            osapidomain = {}
         elif FLAGS.FAKE_subdomain == 'ec2':
             ec2domain = {}
         mapper = routes.Mapper()
         mapper.sub_domains = True
-        mapper.connect("/", controller=self.rsapi_versions, 
-                            conditions=rsdomain)
+        mapper.connect("/", controller=self.osapi_versions, 
+                            conditions=osapidomain)
         mapper.connect("/v1.0/{path_info:.*}", controller=openstack.API(),
-                            conditions=rsdomain)
+                            conditions=osapidomain)
 
         mapper.connect("/", controller=self.ec2api_versions,
                             conditions=ec2domain)
@@ -81,7 +81,7 @@ class API(wsgi.Router):
         super(API, self).__init__(mapper)
 
     @webob.dec.wsgify
-    def rsapi_versions(self, req):
+    def osapi_versions(self, req):
         """Respond to a request for all OpenStack API versions."""
         response = {
                 "versions": [
-- 
cgit 


From da7fa3f388a45b3afca16dba6a59b68ea8804f7a Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren.hansen@rackspace.com>
Date: Tue, 12 Oct 2010 09:24:33 +0200
Subject: APIRequestContext.admin is no more..

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/api')

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 555518448..7839dc92c 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -841,7 +841,7 @@ class CloudController(object):
             inst_id = instance_ref['id']
 
             for security_group_id in security_groups:
-                db.instance_add_security_group(context.admin(), inst_id,
+                db.instance_add_security_group(context, inst_id,
                                                security_group_id)
 
             inst = {}
-- 
cgit 


From a393c7f4cc59111dac678d9e61daa3955e53d548 Mon Sep 17 00:00:00 2001
From: "jaypipes@gmail.com" <>
Date: Wed, 13 Oct 2010 14:17:03 -0400
Subject: Fixes LP Bug#660095.

---
 nova/api/openstack/servers.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 1a0792bf8..cb5132635 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -246,7 +246,7 @@ class Controller(wsgi.Controller):
         inst['launch_index'] = 0
 
         inst['hostname'] = str(ref.internal_id)
-        self.db_driver.instance_update(None, inst['id'], inst)
+        self.db_driver.instance_update(api_context, inst['id'], inst)
 
         network_manager = utils.import_object(FLAGS.network_manager)
         address = network_manager.allocate_fixed_ip(api_context,
@@ -254,20 +254,20 @@ class Controller(wsgi.Controller):
 
         # TODO(vish): This probably should be done in the scheduler
         #             network is setup when host is assigned
-        network_topic = self._get_network_topic(None)
+        network_topic = self._get_network_topic(api_context, network_manager)
         rpc.call(network_topic,
                  {"method": "setup_fixed_ip",
-                  "args": {"context": None,
+                  "args": {"context": api_context,
                            "address": address}})
         return inst
 
-    def _get_network_topic(self, context):
+    def _get_network_topic(self, context, network_manager):
         """Retrieves the network host for a project"""
-        network_ref = self.network_manager.get_network(context)
+        network_ref = network_manager.get_network(context)
         host = network_ref['host']
         if not host:
             host = rpc.call(FLAGS.network_topic,
                                   {"method": "set_network_host",
-                                   "args": {"context": None,
+                                   "args": {"context": context,
                                             "network_id": network_ref['id']}})
         return self.db_driver.queue_get_for(None, FLAGS.network_topic, host)
-- 
cgit 


From 79a2c349ca5772a69b6f7f28a768e711d6db1524 Mon Sep 17 00:00:00 2001
From: Michael Gundlach <michael.gundlach@rackspace.com>
Date: Wed, 13 Oct 2010 16:36:05 -0400
Subject: Fix several problems keeping AuthMiddleware from functioning in the
 OpenStack API.

---
 nova/api/openstack/auth.py | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

(limited to 'nova/api')

diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 4c909293e..7aba55728 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -24,9 +24,9 @@ class BasicApiAuthManager(object):
     def __init__(self, host=None, db_driver=None):
         if not host:
             host = FLAGS.host
-        self.host = host                                                                                                                                     
+        self.host = host
         if not db_driver:
-            db_driver = FLAGS.db_driver                                                                                                                      
+            db_driver = FLAGS.db_driver
         self.db = utils.import_object(db_driver)
         self.auth = auth.manager.AuthManager()
         self.context = Context()
@@ -40,20 +40,19 @@ class BasicApiAuthManager(object):
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
         try:
-            username, key = req.headers['X-Auth-User'], \
-                req.headers['X-Auth-Key']
+            username = req.headers['X-Auth-User']
+            key = req.headers['X-Auth-Key']
         except KeyError:
             return faults.Fault(webob.exc.HTTPUnauthorized())
 
-        username, key = req.headers['X-Auth-User'], req.headers['X-Auth-Key']
         token, user = self._authorize_user(username, key)
         if user and token:
             res = webob.Response()
-            res.headers['X-Auth-Token'] = token['token_hash']
+            res.headers['X-Auth-Token'] = token.token_hash
             res.headers['X-Server-Management-Url'] = \
-                token['server_management_url']
-            res.headers['X-Storage-Url'] = token['storage_url']
-            res.headers['X-CDN-Management-Url'] = token['cdn_management_url']
+                token.server_management_url
+            res.headers['X-Storage-Url'] = token.storage_url
+            res.headers['X-CDN-Management-Url'] = token.cdn_management_url
             res.content_type = 'text/plain'
             res.status = '204'
             return res
@@ -65,34 +64,35 @@ class BasicApiAuthManager(object):
         
         If the token has expired, returns None
         If the token is not found, returns None
-        Otherwise returns the token
+        Otherwise returns dict(id=(the authorized user's id))
 
         This method will also remove the token if the timestamp is older than
         2 days ago.
         """
         token = self.db.auth_get_token(self.context, token_hash) 
         if token:
-            delta = datetime.datetime.now() - token['created_at']
+            delta = datetime.datetime.now() - token.created_at
             if delta.days >= 2:
                 self.db.auth_destroy_token(self.context, token)
             else:
-                user = self.auth.get_user(token['user_id'])
-                return { 'id':user['uid'] }
+                #TODO(gundlach): Why not just return dict(id=token.user_id)?
+                user = self.auth.get_user(token.user_id)
+                return {'id': user.id}
         return None
 
     def _authorize_user(self, username, key):
         """ Generates a new token and assigns it to a user """
         user = self.auth.get_user_from_access_key(key)
-        if user and user['name'] == username:
+        if user and user.name == username:
             token_hash = hashlib.sha1('%s%s%f' % (username, key,
                 time.time())).hexdigest()
-            token = {}
-            token['token_hash'] = token_hash
-            token['cdn_management_url'] = ''
-            token['server_management_url'] = self._get_server_mgmt_url()
-            token['storage_url'] = ''
-            token['user_id'] = user['uid']
-            self.db.auth_create_token(self.context, token)
+            token_dict = {}
+            token_dict['token_hash'] = token_hash
+            token_dict['cdn_management_url'] = ''
+            token_dict['server_management_url'] = self._get_server_mgmt_url()
+            token_dict['storage_url'] = ''
+            token_dict['user_id'] = user.id
+            token = self.db.auth_create_token(self.context, token_dict)
             return token, user
         return None, None 
 
-- 
cgit