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 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 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