Merged trunk

8 files changed, 32 insertions, 210 deletions

diff --git a/nova/api/__init__.py b/nova/api/__init__.py
index 803470570..0fedbbfad 100644
--- a/nova/api/__init__.py
+++ b/nova/api/__init__.py
@@ -15,96 +15,5 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-"""
-Root WSGI middleware for all API controllers.
 
-**Related Flags**
-
-:osapi_subdomain:  subdomain running the OpenStack API (default: api)
-:ec2api_subdomain:  subdomain running the EC2 API (default: ec2)
-
-"""
-
-import routes
-import webob.dec
-
-from nova import flags
-from nova import wsgi
-from nova.api import ec2
-from nova.api import openstack
-from nova.api.ec2 import metadatarequesthandler
-
-
-flags.DEFINE_string('osapi_subdomain', 'api',
-                    'subdomain running the OpenStack API')
-flags.DEFINE_string('ec2api_subdomain', 'ec2',
-                    'subdomain running the EC2 API')
-
-FLAGS = flags.FLAGS
-
-
-class API(wsgi.Router):
-    """Routes top-level requests to the appropriate controller."""
-
-    def __init__(self, default_api):
-        osapi_subdomain = {'sub_domain': [FLAGS.osapi_subdomain]}
-        ec2api_subdomain = {'sub_domain': [FLAGS.ec2api_subdomain]}
-        if default_api == 'os':
-            osapi_subdomain = {}
-        elif default_api == 'ec2':
-            ec2api_subdomain = {}
-        mapper = routes.Mapper()
-        mapper.sub_domains = True
-
-        mapper.connect("/", controller=self.osapi_versions,
-                       conditions=osapi_subdomain)
-        mapper.connect("/v1.0/{path_info:.*}", controller=openstack.API(),
-                       conditions=osapi_subdomain)
-
-        mapper.connect("/", controller=self.ec2api_versions,
-                       conditions=ec2api_subdomain)
-        mapper.connect("/services/{path_info:.*}", controller=ec2.API(),
-                       conditions=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=ec2api_subdomain)
-
-        super(API, self).__init__(mapper)
-
-    @webob.dec.wsgify
-    def osapi_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)
-
-    @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)
+"""No-op __init__ for directory full of api goodies."""
diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 2fa1f636c..238cb0f38 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -30,10 +30,9 @@ from nova import context
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import utils
 from nova import wsgi
 from nova.api.ec2 import apirequest
-from nova.api.ec2 import admin
-from nova.api.ec2 import cloud
 from nova.auth import manager
 
 
@@ -42,8 +41,6 @@ LOG = logging.getLogger("nova.api")
 flags.DEFINE_boolean('use_forwarded_for', False,
                      'Treat X-Forwarded-For as the canonical remote address. '
                      'Only enable this if you have a sanitizing proxy.')
-flags.DEFINE_boolean('use_lockout', False,
-                     'Whether or not to use lockout middleware.')
 flags.DEFINE_integer('lockout_attempts', 5,
                      'Number of failed auths before lockout.')
 flags.DEFINE_integer('lockout_minutes', 15,
@@ -54,13 +51,8 @@ flags.DEFINE_list('lockout_memcached_servers', None,
                   'Memcached servers or None for in process cache.')
 
 
-class API(wsgi.Middleware):
-    """Routing for all EC2 API requests."""
-
-    def __init__(self):
-        self.application = Authenticate(Router(Authorizer(Executor())))
-        if FLAGS.use_lockout:
-            self.application = Lockout(self.application)
+class RequestLogging(wsgi.Middleware):
+    """Access-Log akin logging for all EC2 API requests."""
 
     @webob.dec.wsgify
     def __call__(self, req):
@@ -192,26 +184,14 @@ class Authenticate(wsgi.Middleware):
         return self.application
 
 
-class Router(wsgi.Middleware):
-
-    """Add ec2.'controller', .'action', and .'action_args' to WSGI environ."""
+class Requestify(wsgi.Middleware):
 
-    def __init__(self, application):
-        super(Router, self).__init__(application)
-        self.map = routes.Mapper()
-        self.map.connect("/{controller_name}/")
-        self.controllers = dict(Cloud=cloud.CloudController(),
-                                Admin=admin.AdminController())
+    def __init__(self, app, controller):
+        super(Requestify, self).__init__(app)
+        self.controller = utils.import_class(controller)()
 
     @webob.dec.wsgify
     def __call__(self, req):
-        # Obtain the appropriate controller and action for this request.
-        try:
-            match = self.map.match(req.path_info)
-            controller_name = match['controller_name']
-            controller = self.controllers[controller_name]
-        except:
-            raise webob.exc.HTTPNotFound()
         non_args = ['Action', 'Signature', 'AWSAccessKeyId', 'SignatureMethod',
                     'SignatureVersion', 'Version', 'Timestamp']
         args = dict(req.params)
@@ -229,8 +209,8 @@ class Router(wsgi.Middleware):
             LOG.debug(_('arg: %s\t\tval: %s'), key, value)
 
         # Success!
-        req.environ['ec2.controller'] = controller
-        req.environ['ec2.action'] = action
+        api_request = apirequest.APIRequest(self.controller, action, args)
+        req.environ['ec2.request'] = api_request
         req.environ['ec2.action_args'] = args
         return self.application
 
@@ -291,16 +271,14 @@ class Authorizer(wsgi.Middleware):
     @webob.dec.wsgify
     def __call__(self, req):
         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,
-                                                               ['none'])
+        controller = req.environ['ec2.request'].controller.__class__.__name__
+        action = req.environ['ec2.request'].action
+        allowed_roles = self.action_roles[controller].get(action, ['none'])
         if self._matches_any_role(context, allowed_roles):
             return self.application
         else:
             LOG.audit(_("Unauthorized request for controller=%s "
-                        "and action=%s"), controller_name, action,
-                      context=context)
+                        "and action=%s"), controller, action, context=context)
             raise webob.exc.HTTPUnauthorized()
 
     def _matches_any_role(self, context, roles):
@@ -327,14 +305,10 @@ class Executor(wsgi.Application):
     @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.APIRequest(controller, action)
+        api_request = req.environ['ec2.request']
         result = None
         try:
-            result = api_request.send(context, **args)
+            result = api_request.invoke(context)
         except exception.NotFound as ex:
             LOG.info(_('NotFound raised: %s'), str(ex),  context=context)
             return self._error(req, context, type(ex).__name__, str(ex))
@@ -391,29 +365,3 @@ class Versions(wsgi.Application):
             '2009-04-04',
         ]
         return ''.join('%s\n' % v for v in versions)
-
-
-def authenticate_factory(global_args, **local_args):
-    def authenticator(app):
-        return Authenticate(app)
-    return authenticator
-
-
-def router_factory(global_args, **local_args):
-    def router(app):
-        return Router(app)
-    return router
-
-
-def authorizer_factory(global_args, **local_args):
-    def authorizer(app):
-        return Authorizer(app)
-    return authorizer
-
-
-def executor_factory(global_args, **local_args):
-    return Executor()
-
-
-def versions_factory(global_args, **local_args):
-    return Versions()
diff --git a/nova/api/ec2/apirequest.py b/nova/api/ec2/apirequest.py
index d0b417db1..78576470a 100644
--- a/nova/api/ec2/apirequest.py
+++ b/nova/api/ec2/apirequest.py
@@ -83,11 +83,12 @@ def _try_convert(value):
 
 
 class APIRequest(object):
-    def __init__(self, controller, action):
+    def __init__(self, controller, action, args):
         self.controller = controller
         self.action = action
+        self.args = args
 
-    def send(self, context, **kwargs):
+    def invoke(self, context):
         try:
             method = getattr(self.controller,
                              _camelcase_to_underscore(self.action))
@@ -100,7 +101,7 @@ class APIRequest(object):
             raise Exception(_error)
 
         args = {}
-        for key, value in kwargs.items():
+        for key, value in self.args.items():
             parts = key.split(".")
             key = _camelcase_to_underscore(parts[0])
             if isinstance(value, str) or isinstance(value, unicode):
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index a1ae70fb0..57d41ed67 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -254,15 +254,15 @@ class CloudController(object):
                 name, _sep, host = region.partition('=')
                 endpoint = '%s://%s:%s%s' % (FLAGS.ec2_prefix,
                                              host,
-                                             FLAGS.cc_port,
+                                             FLAGS.ec2_port,
                                              FLAGS.ec2_suffix)
                 regions.append({'regionName': name,
                                 'regionEndpoint': endpoint})
         else:
             regions = [{'regionName': 'nova',
                         'regionEndpoint': '%s://%s:%s%s' % (FLAGS.ec2_prefix,
-                                                            FLAGS.cc_host,
-                                                            FLAGS.cc_port,
+                                                            FLAGS.ec2_host,
+                                                            FLAGS.ec2_port,
                                                             FLAGS.ec2_suffix)}]
         return {'regionInfo': regions}
 
diff --git a/nova/api/ec2/metadatarequesthandler.py b/nova/api/ec2/metadatarequesthandler.py
index 848f0b034..6fb441656 100644
--- a/nova/api/ec2/metadatarequesthandler.py
+++ b/nova/api/ec2/metadatarequesthandler.py
@@ -23,6 +23,7 @@ import webob.exc
 
 from nova import log as logging
 from nova import flags
+from nova import wsgi
 from nova.api.ec2 import cloud
 
 
@@ -30,7 +31,7 @@ LOG = logging.getLogger('nova.api.ec2.metadata')
 FLAGS = flags.FLAGS
 
 
-class MetadataRequestHandler(object):
+class MetadataRequestHandler(wsgi.Application):
     """Serve metadata from the EC2 API."""
 
     def print_data(self, data):
@@ -78,7 +79,3 @@ class MetadataRequestHandler(object):
         if data is None:
             raise webob.exc.HTTPNotFound()
         return self.print_data(data)
-
-
-def metadata_factory(global_args, **local_args):
-    return MetadataRequestHandler()
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index a9b01548a..4767e518f 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -23,11 +23,9 @@ WSGI middleware for OpenStack API controllers.
 import routes
 import webob.dec
 import webob.exc
-import webob
 
 from nova import flags
 from nova import log as logging
-from nova import utils
 from nova import wsgi
 from nova.api.openstack import faults
 from nova.api.openstack import backup_schedules
@@ -40,32 +38,16 @@ from nova.api.openstack import shared_ip_groups
 
 LOG = logging.getLogger('nova.api.openstack')
 FLAGS = flags.FLAGS
-flags.DEFINE_string('os_api_auth',
-    'nova.api.openstack.auth.AuthMiddleware',
-    'The auth mechanism to use for the OpenStack API implemenation')
-
-flags.DEFINE_string('os_api_ratelimiting',
-    'nova.api.openstack.ratelimiting.RateLimitingMiddleware',
-    'Default ratelimiting implementation for the Openstack API')
-
 flags.DEFINE_string('os_krm_mapping_file',
     'krm_mapping.json',
     'Location of OpenStack Flavor/OS:EC2 Kernel/Ramdisk/Machine JSON file.')
-
 flags.DEFINE_bool('allow_admin_api',
     False,
     'When True, this API service will accept admin operations.')
 
 
-class API(wsgi.Middleware):
-    """WSGI entry point for all OpenStack API requests."""
-
-    def __init__(self):
-        auth_middleware = utils.import_class(FLAGS.os_api_auth)
-        ratelimiting_middleware = \
-            utils.import_class(FLAGS.os_api_ratelimiting)
-        app = auth_middleware(ratelimiting_middleware(APIRouter()))
-        super(API, self).__init__(app)
+class FaultWrapper(wsgi.Middleware):
+    """Calls down the middleware stack, making exceptions into faults."""
 
     @webob.dec.wsgify
     def __call__(self, req):
@@ -83,6 +65,11 @@ class APIRouter(wsgi.Router):
     and method.
     """
 
+    @classmethod
+    def factory(cls, global_config, **local_config):
+        """Simple paste factory, :class:`nova.wsgi.Router` doesn't have one"""
+        return cls()
+
     def __init__(self):
         mapper = routes.Mapper()
 
@@ -134,11 +121,3 @@ class Versions(wsgi.Application):
             "application/xml": {
                 "attributes": dict(version=["status", "id"])}}
         return wsgi.Serializer(req.environ, metadata).to_content_type(response)
-
-
-def router_factory(global_cof, **local_conf):
-    return APIRouter()
-
-
-def versions_factory(global_conf, **local_conf):
-    return Versions()
diff --git a/nova/api/openstack/auth.py b/nova/api/openstack/auth.py
index 00e817c8d..1dfdd5318 100644
--- a/nova/api/openstack/auth.py
+++ b/nova/api/openstack/auth.py
@@ -134,9 +134,3 @@ class AuthMiddleware(wsgi.Middleware):
             token = self.db.auth_create_token(ctxt, token_dict)
             return token, user
         return None, None
-
-
-def auth_factory(global_conf, **local_conf):
-    def auth(app):
-        return AuthMiddleware(app)
-    return auth
diff --git a/nova/api/openstack/ratelimiting/__init__.py b/nova/api/openstack/ratelimiting/__init__.py
index 81b83142f..cbb4b897e 100644
--- a/nova/api/openstack/ratelimiting/__init__.py
+++ b/nova/api/openstack/ratelimiting/__init__.py
@@ -219,9 +219,3 @@ class WSGIAppProxy(object):
             # No delay
             return None
         return float(resp.getheader('X-Wait-Seconds'))
-
-
-def ratelimit_factory(global_conf, **local_conf):
-    def rl(app):
-        return RateLimitingMiddleware(app)
-    return rl