merge trunk

10 files changed, 241 insertions, 41 deletions

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 092b80fa2..be5dd38a0 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -906,7 +906,7 @@ class CloudController(object):
         try:
             internal_id = ec2utils.ec2_id_to_id(ec2_id)
             return self.image_service.show(context, internal_id)
-        except ValueError:
+        except (exception.InvalidEc2Id, exception.ImageNotFound):
             try:
                 return self.image_service.show_by_name(context, ec2_id)
             except exception.NotFound:
diff --git a/nova/api/ec2/ec2utils.py b/nova/api/ec2/ec2utils.py
index 1ac48163c..163aa4ed2 100644
--- a/nova/api/ec2/ec2utils.py
+++ b/nova/api/ec2/ec2utils.py
@@ -21,7 +21,10 @@ from nova import exception
 
 def ec2_id_to_id(ec2_id):
     """Convert an ec2 ID (i-[base 16 number]) to an instance id (int)"""
-    return int(ec2_id.split('-')[-1], 16)
+    try:
+        return int(ec2_id.split('-')[-1], 16)
+    except ValueError:
+        raise exception.InvalidEc2Id(ec2_id=ec2_id)
 
 
 def id_to_ec2_id(instance_id, template='i-%08x'):
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 5e76a06f7..348b70d5b 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -112,9 +112,6 @@ class APIRouter(wsgi.Router):
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
-        _limits = limits.LimitsController()
-        mapper.resource("limit", "limits", controller=_limits)
-
         super(APIRouter, self).__init__(mapper)
 
 
@@ -145,6 +142,9 @@ class APIRouterV10(APIRouter):
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
+        mapper.resource("limit", "limits",
+                        controller=limits.LimitsControllerV10())
+
         mapper.resource("ip", "ips", controller=ips.Controller(),
                         collection=dict(public='GET', private='GET'),
                         parent_resource=dict(member_name='server',
@@ -178,3 +178,6 @@ class APIRouterV11(APIRouter):
         mapper.resource("flavor", "flavors",
                         controller=flavors.ControllerV11(),
                         collection={'detail': 'GET'})
+
+        mapper.resource("limit", "limits",
+                        controller=limits.LimitsControllerV11())
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 65ed1e143..32cd689ca 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import re
 from urlparse import urlparse
 
 import webob
@@ -130,10 +131,16 @@ def get_image_id_from_image_hash(image_service, context, image_hash):
 def get_id_from_href(href):
     """Return the id portion of a url as an int.
 
-    Given: http://www.foo.com/bar/123?q=4
+    Given: 'http://www.foo.com/bar/123?q=4'
+    Returns: 123
+
+    In order to support local hrefs, the href argument can be just an id:
+    Given: '123'
     Returns: 123
 
     """
+    if re.match(r'\d+$', str(href)):
+        return int(href)
     try:
         return int(urlparse(href).path.split('/')[-1])
     except:
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 77baf5947..34d4c27fc 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -127,7 +127,7 @@ class Controller(common.OpenstackController):
             raise webob.exc.HTTPBadRequest()
 
         image = self._compute_service.snapshot(context, server_id, image_name)
-        return self.get_builder(req).build(image, detail=True)
+        return dict(image=self.get_builder(req).build(image, detail=True))
 
     def get_builder(self, request):
         """Indicates that you must use a Controller subclass."""
diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index 9877af191..47bc238f1 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -33,7 +33,7 @@ from webob.dec import wsgify
 from nova import wsgi
 from nova.api.openstack import common
 from nova.api.openstack import faults
-from nova.wsgi import Middleware
+from nova.api.openstack.views import limits as limits_views
 
 
 # Convenience constants for the limits dictionary passed to Limiter().
@@ -51,8 +51,8 @@ class LimitsController(common.OpenstackController):
     _serialization_metadata = {
         "application/xml": {
             "attributes": {
-                "limit": ["verb", "URI", "regex", "value", "unit",
-                    "resetTime", "remaining", "name"],
+                "limit": ["verb", "URI", "uri", "regex", "value", "unit",
+                    "resetTime", "next-available", "remaining", "name"],
             },
             "plurals": {
                 "rate": "limit",
@@ -67,12 +67,21 @@ class LimitsController(common.OpenstackController):
         abs_limits = {}
         rate_limits = req.environ.get("nova.limits", [])
 
-        return {
-            "limits": {
-                "rate": rate_limits,
-                "absolute": abs_limits,
-            },
-        }
+        builder = self._get_view_builder(req)
+        return builder.build(rate_limits, abs_limits)
+
+    def _get_view_builder(self, req):
+        raise NotImplementedError()
+
+
+class LimitsControllerV10(LimitsController):
+    def _get_view_builder(self, req):
+        return limits_views.ViewBuilderV10()
+
+
+class LimitsControllerV11(LimitsController):
+    def _get_view_builder(self, req):
+        return limits_views.ViewBuilderV11()
 
 
 class Limit(object):
@@ -186,7 +195,7 @@ DEFAULT_LIMITS = [
 ]
 
 
-class RateLimitingMiddleware(Middleware):
+class RateLimitingMiddleware(wsgi.Middleware):
     """
     Rate-limits requests passing through this middleware. All limit information
     is stored in memory for this implementation.
@@ -200,7 +209,7 @@ class RateLimitingMiddleware(Middleware):
         @param application: WSGI application to wrap
         @param limits: List of dictionaries describing limits
         """
-        Middleware.__init__(self, application)
+        wsgi.Middleware.__init__(self, application)
         self._limiter = Limiter(limits or DEFAULT_LIMITS)
 
     @wsgify(RequestClass=wsgi.Request)
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 9b883f06b..547310613 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -14,28 +14,25 @@
 #    under the License.
 
 import base64
-import hashlib
 import traceback
 
 from webob import exc
 from xml.dom import minidom
 
 from nova import compute
-from nova import context
 from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import quota
 from nova import utils
-from nova import wsgi
 from nova.api.openstack import common
 from nova.api.openstack import faults
 import nova.api.openstack.views.addresses
 import nova.api.openstack.views.flavors
+import nova.api.openstack.views.images
 import nova.api.openstack.views.servers
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
-from nova.compute import power_state
 import nova.api.openstack
 from nova.scheduler import api as scheduler_api
 
@@ -320,10 +317,6 @@ class Controller(common.OpenstackController):
             return faults.Fault(exc.HTTPBadRequest())
         return exc.HTTPAccepted()
 
-    def _action_rebuild(self, input_dict, req, id):
-        LOG.debug(_("Rebuild server action is not implemented"))
-        return faults.Fault(exc.HTTPNotImplemented())
-
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
         try:
@@ -595,19 +588,35 @@ class ControllerV10(Controller):
         return nova.api.openstack.views.servers.ViewBuilderV10(
             addresses_builder)
 
-    def _get_addresses_view_builder(self, req):
-        return nova.api.openstack.views.addresses.ViewBuilderV10(req)
-
     def _limit_items(self, items, req):
         return common.limited(items, req)
 
     def _parse_update(self, context, server_id, inst_dict, update_dict):
         if 'adminPass' in inst_dict['server']:
             update_dict['admin_pass'] = inst_dict['server']['adminPass']
-            try:
-                self.compute_api.set_admin_password(context, server_id)
-            except exception.TimeoutException:
-                return exc.HTTPRequestTimeout()
+            self.compute_api.set_admin_password(context, server_id)
+
+    def _action_rebuild(self, info, request, instance_id):
+        context = request.environ['nova.context']
+        instance_id = int(instance_id)
+
+        try:
+            image_id = info["rebuild"]["imageId"]
+        except (KeyError, TypeError):
+            msg = _("Could not parse imageId from request.")
+            LOG.debug(msg)
+            return faults.Fault(exc.HTTPBadRequest(explanation=msg))
+
+        try:
+            self.compute_api.rebuild(context, instance_id, image_id)
+        except exception.BuildInProgress:
+            msg = _("Instance %d is currently being rebuilt.") % instance_id
+            LOG.debug(msg)
+            return faults.Fault(exc.HTTPConflict(explanation=msg))
+
+        response = exc.HTTPAccepted()
+        response.empty_body = True
+        return response
 
 
 class ControllerV11(Controller):
@@ -629,9 +638,6 @@ class ControllerV11(Controller):
         return nova.api.openstack.views.servers.ViewBuilderV11(
             addresses_builder, flavor_builder, image_builder, base_url)
 
-    def _get_addresses_view_builder(self, req):
-        return nova.api.openstack.views.addresses.ViewBuilderV11(req)
-
     def _action_change_password(self, input_dict, req, id):
         context = req.environ['nova.context']
         if (not 'changePassword' in input_dict
@@ -648,6 +654,63 @@ class ControllerV11(Controller):
     def _limit_items(self, items, req):
         return common.limited_by_marker(items, req)
 
+    def _validate_metadata(self, metadata):
+        """Ensure that we can work with the metadata given."""
+        try:
+            metadata.iteritems()
+        except AttributeError as ex:
+            msg = _("Unable to parse metadata key/value pairs.")
+            LOG.debug(msg)
+            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+
+    def _decode_personalities(self, personalities):
+        """Decode the Base64-encoded personalities."""
+        for personality in personalities:
+            try:
+                path = personality["path"]
+                contents = personality["contents"]
+            except (KeyError, TypeError):
+                msg = _("Unable to parse personality path/contents.")
+                LOG.info(msg)
+                raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+
+            try:
+                personality["contents"] = base64.b64decode(contents)
+            except TypeError:
+                msg = _("Personality content could not be Base64 decoded.")
+                LOG.info(msg)
+                raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+
+    def _action_rebuild(self, info, request, instance_id):
+        context = request.environ['nova.context']
+        instance_id = int(instance_id)
+
+        try:
+            image_ref = info["rebuild"]["imageRef"]
+        except (KeyError, TypeError):
+            msg = _("Could not parse imageRef from request.")
+            LOG.debug(msg)
+            return faults.Fault(exc.HTTPBadRequest(explanation=msg))
+
+        image_id = common.get_id_from_href(image_ref)
+        personalities = info["rebuild"].get("personality", [])
+        metadata = info["rebuild"].get("metadata", {})
+
+        self._validate_metadata(metadata)
+        self._decode_personalities(personalities)
+
+        try:
+            self.compute_api.rebuild(context, instance_id, image_id, metadata,
+                                     personalities)
+        except exception.BuildInProgress:
+            msg = _("Instance %d is currently being rebuilt.") % instance_id
+            LOG.debug(msg)
+            return faults.Fault(exc.HTTPConflict(explanation=msg))
+
+        response = exc.HTTPAccepted()
+        response.empty_body = True
+        return response
+
     def _get_server_admin_password(self, server):
         """ Determine the admin password for a server on creation """
         password = server.get('adminPass')
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index 9dec8a355..2773c9c13 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -46,6 +46,14 @@ class ViewBuilder(object):
         except KeyError:
             image['status'] = image['status'].upper()
 
+    def _build_server(self, image, instance_id):
+        """Indicates that you must use a ViewBuilder subclass."""
+        raise NotImplementedError
+
+    def generate_server_ref(self, server_id):
+        """Return an href string pointing to this server."""
+        return os.path.join(self._url, "servers", str(server_id))
+
     def generate_href(self, image_id):
         """Return an href string pointing to this object."""
         return os.path.join(self._url, "images", str(image_id))
@@ -66,7 +74,7 @@ class ViewBuilder(object):
 
         if "instance_id" in properties:
             try:
-                image["serverId"] = int(properties["instance_id"])
+                self._build_server(image, int(properties["instance_id"]))
             except ValueError:
                 pass
 
@@ -85,12 +93,17 @@ class ViewBuilder(object):
 
 class ViewBuilderV10(ViewBuilder):
     """OpenStack API v1.0 Image Builder"""
-    pass
+
+    def _build_server(self, image, instance_id):
+        image["serverId"] = instance_id
 
 
 class ViewBuilderV11(ViewBuilder):
     """OpenStack API v1.1 Image Builder"""
 
+    def _build_server(self, image, instance_id):
+        image["serverRef"] = self.generate_server_ref(instance_id)
+
     def build(self, image_obj, detail=False):
         """Return a standardized image structure for display by the API."""
         image = ViewBuilder.build(self, image_obj, detail)
diff --git a/nova/api/openstack/views/limits.py b/nova/api/openstack/views/limits.py
new file mode 100644
index 000000000..552db39ee
--- /dev/null
+++ b/nova/api/openstack/views/limits.py
@@ -0,0 +1,100 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 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 nova.api.openstack import common
+
+
+class ViewBuilder(object):
+    """Openstack API base limits view builder."""
+
+    def build(self, rate_limits, absolute_limits):
+        rate_limits = self._build_rate_limits(rate_limits)
+        absolute_limits = self._build_absolute_limits(absolute_limits)
+
+        output = {
+            "limits": {
+                "rate": rate_limits,
+                "absolute": absolute_limits,
+            },
+        }
+
+        return output
+
+
+class ViewBuilderV10(ViewBuilder):
+    """Openstack API v1.0 limits view builder."""
+
+    def _build_rate_limits(self, rate_limits):
+        return [self._build_rate_limit(r) for r in rate_limits]
+
+    def _build_rate_limit(self, rate_limit):
+        return {
+            "verb": rate_limit["verb"],
+            "URI": rate_limit["URI"],
+            "regex": rate_limit["regex"],
+            "value": rate_limit["value"],
+            "remaining": int(rate_limit["remaining"]),
+            "unit": rate_limit["unit"],
+            "resetTime": rate_limit["resetTime"],
+        }
+
+    def _build_absolute_limits(self, absolute_limit):
+        return {}
+
+
+class ViewBuilderV11(ViewBuilder):
+    """Openstack API v1.1 limits view builder."""
+
+    def _build_rate_limits(self, rate_limits):
+        limits = []
+        for rate_limit in rate_limits:
+            _rate_limit_key = None
+            _rate_limit = self._build_rate_limit(rate_limit)
+
+            # check for existing key
+            for limit in limits:
+                if limit["uri"] == rate_limit["URI"] and \
+                   limit["regex"] == limit["regex"]:
+                    _rate_limit_key = limit
+                    break
+
+            # ensure we have a key if we didn't find one
+            if not _rate_limit_key:
+                _rate_limit_key = {
+                    "uri": rate_limit["URI"],
+                    "regex": rate_limit["regex"],
+                    "limit": [],
+                }
+                limits.append(_rate_limit_key)
+
+            _rate_limit_key["limit"].append(_rate_limit)
+
+        return limits
+
+    def _build_rate_limit(self, rate_limit):
+        return {
+            "verb": rate_limit["verb"],
+            "value": rate_limit["value"],
+            "remaining": int(rate_limit["remaining"]),
+            "unit": rate_limit["unit"],
+            "next-available": rate_limit["resetTime"],
+        }
+
+    def _build_absolute_limits(self, absolute_limit):
+        return {}
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index e52bfaea3..0be468edc 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -63,10 +63,12 @@ class ViewBuilder(object):
             power_state.BLOCKED: 'ACTIVE',
             power_state.SUSPENDED: 'SUSPENDED',
             power_state.PAUSED: 'PAUSED',
-            power_state.SHUTDOWN: 'ACTIVE',
-            power_state.SHUTOFF: 'ACTIVE',
+            power_state.SHUTDOWN: 'SHUTDOWN',
+            power_state.SHUTOFF: 'SHUTOFF',
             power_state.CRASHED: 'ERROR',
-            power_state.FAILED: 'ERROR'}
+            power_state.FAILED: 'ERROR',
+            power_state.BUILDING: 'BUILD',
+        }
 
         inst_dict = {
             'id': int(inst['id']),