Merge lp:~rconradharris/glance/add_registry_adapter into lp:~hudson-openstack/glance/trunk

[Rick Harris]

This patch:
  * Decouples Controller for ParallaxAdapter implementation by adding generic RegistryAdapter and providing a lookup function
  * Adds base model attributes to Parallax's JSON (created_at, etc)

[Jay Pipes (jaypipes)]

Excellent work overall, Rick.

A couple tiny issues with double-up vim headers and whitespace, but that is entirely style-related and shouldn't hold up this work. Nice work making the registry layer adaptable.

-jay

review: Approve

[Christopher MacGown (0x44)]

This is great, thanks Rick.

review: Approve

=== modified file 'bin/parallax-server.py'
--- bin/parallax-server.py	2010-09-29 05:14:03 +0000
+++ bin/parallax-server.py	2010-10-01 23:24:45 +0000
@@ -36,7 +36,7 @@
 from glance.common import utils
 from glance.common import server
 from glance.common import wsgi
-from glance.parallax import api
+from glance.parallax import controllers
 
 
 FLAGS = flags.FLAGS
@@ -44,7 +44,7 @@
 flags.DEFINE_integer('parallax_port', 9191, 'Parallax port')
 
 def main(_args):
-    wsgi.run_server(api.API(), FLAGS.parallax_port)
+    wsgi.run_server(controllers.API(), FLAGS.parallax_port)
 
 if __name__ == '__main__':
     utils.default_flagfile()

=== added file 'bin/teller-server.py'
--- bin/teller-server.py	1970-01-01 00:00:00 +0000
+++ bin/teller-server.py	2010-10-01 23:24:45 +0000
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+# pylint: disable-msg=C0103
+# 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.
+"""
+Teller API daemon.
+"""
+
+import os
+import sys
+
+# If ../parallax/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'teller', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+from glance.common import flags
+from glance.common import utils
+from glance.common import server
+from glance.common import wsgi
+from glance.teller import controllers
+
+
+FLAGS = flags.FLAGS
+# TODO(sirp): ensure no conflicts in port selection
+flags.DEFINE_integer('teller_port', 9292, 'Teller port')
+
+def main(_args):
+    wsgi.run_server(controllers.API(), FLAGS.teller_port)
+
+if __name__ == '__main__':
+    utils.default_flagfile()
+    server.serve('teller-server', main)

=== modified file 'glance/common/db/__init__.py'
--- glance/common/db/__init__.py	2010-09-29 05:14:03 +0000
+++ glance/common/db/__init__.py	2010-10-01 23:24:45 +0000
@@ -20,4 +20,3 @@
 DB abstraction for Nova and Glance
 """
 
-from glance.common.db.api import *

=== modified file 'glance/common/db/sqlalchemy/__init__.py'
--- glance/common/db/sqlalchemy/__init__.py	2010-09-29 05:14:03 +0000
+++ glance/common/db/sqlalchemy/__init__.py	2010-10-01 23:24:45 +0000
@@ -1,24 +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.
-
-"""
-SQLAlchemy database backend
-"""
-from glance.common.db.sqlalchemy import models
-
-models.register_models()

=== modified file 'glance/common/wsgi.py'
--- glance/common/wsgi.py	2010-09-29 04:54:27 +0000
+++ glance/common/wsgi.py	2010-10-01 23:24:45 +0000
@@ -23,6 +23,7 @@
 
 import logging
 import sys
+import datetime
 
 import eventlet
 import eventlet.wsgi
@@ -260,7 +261,12 @@
 
     def _to_json(self, data):
         import json
-        return json.dumps(data)
+        def sanitizer(obj):
+            if isinstance(obj, datetime.datetime):
+                return obj.isoformat()
+            return obj
+
+        return json.dumps(data, default=sanitizer)
 
     def _to_xml(self, data):
         metadata = self.metadata.get('application/xml', {})

=== removed directory 'glance/parallax/api'
=== removed file 'glance/parallax/api/__init__.py'
--- glance/parallax/api/__init__.py	2010-09-29 20:51:21 +0000
+++ glance/parallax/api/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,49 +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.
-
-"""
-Parallax API controllers.
-"""
-
-import json
-import time
-
-import routes
-import webob.dec
-import webob.exc
-import webob
-
-from glance.common import flags
-from glance.common import utils
-from glance.common import wsgi
-from glance.parallax.api import images
-
-
-FLAGS = flags.FLAGS
-
-
-class API(wsgi.Router):
-    """WSGI entry point for all Parallax requests."""
-
-    def __init__(self):
-        # TODO(sirp): should we add back the middleware for parallax
-        mapper = routes.Mapper()
-        mapper.resource("image", "images", controller=images.Controller(),
-                        collection={'detail': 'GET'})
-        super(API, self).__init__(mapper)
-

=== removed file 'glance/parallax/api/images.py'
--- glance/parallax/api/images.py	2010-09-29 20:51:21 +0000
+++ glance/parallax/api/images.py	1970-01-01 00:00:00 +0000
@@ -1,82 +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.
-
-"""
-Parllax Image controller
-"""
-
-
-from glance.common import wsgi
-from glance.common import db
-from glance.common import exception
-from webob import exc
-
-
-class Controller(wsgi.Controller):
-    """Image Controller """
-
-    # TODO(sirp): this is not currently used, but should eventually
-    # incorporate it
-    _serialization_metadata = {
-        'application/xml': {
-            "attributes": {
-                "image": [ "id", "name", "updated", "created", "status",
-                           "serverId", "progress" ]
-            }
-        }
-    }
-
-    def index(self, req):
-        """Index is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def detail(self, req):
-        """Detail is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def show(self, req, id):
-        """Return data about the given image id."""
-        try:
-            image = db.image_get(None, id)
-        except exception.NotFound:
-            raise exc.HTTPNotFound()
-
-        file_dicts = [dict(location=f.location, size=f.size)
-                      for f in image.files]
-
-        metadata_dicts = [dict(key=m.key, value=m.value)
-                          for m in image.metadata]
-        
-        return dict(id=image.id, 
-                    name=image.name,
-                    state=image.state,
-                    public=image.public,
-                    files=file_dicts,
-                    metadata=metadata_dicts)
-
-    def delete(self, req, id):
-        """Delete is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def create(self, req):
-        """Create is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def update(self, req, id):
-        """Update is not currently supported """
-        raise exc.HTTPNotImplemented()
-

=== added file 'glance/parallax/controllers.py'
--- glance/parallax/controllers.py	1970-01-01 00:00:00 +0000
+++ glance/parallax/controllers.py	2010-10-01 23:24:45 +0000
@@ -0,0 +1,114 @@
+# 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.
+"""
+Parllax Image controller
+"""
+
+import routes
+from glance.common import wsgi
+from glance.common import exception
+from glance.parallax import db
+from webob import exc
+
+
+class ImageController(wsgi.Controller):
+    """Image Controller """
+    
+    def index(self, req):
+        """Return data for all public, non-deleted images """
+        images = db.image_get_all_public(None)
+        image_dicts = [self._make_image_dict(i) for i in images]
+        return dict(images=image_dicts)
+
+    def detail(self, req):
+        """Detail is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def show(self, req, id):
+        """Return data about the given image id."""
+        try:
+            image = db.image_get(None, id)
+        except exception.NotFound:
+            raise exc.HTTPNotFound()
+        
+        return dict(image=self._make_image_dict(image))
+
+    def delete(self, req, id):
+        """Delete is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def create(self, req):
+        """Create is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def update(self, req, id):
+        """Update is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    @staticmethod
+    def _make_image_dict(image):
+        """ Create a dict represenation of an image which we can use to
+        serialize the image.
+        """
+        def _fetch_attrs(obj, attrs):
+            return dict([(a, getattr(obj, a)) for a in attrs])
+
+        # attributes common to all models
+        base_attrs = set(['id', 'created_at', 'updated_at', 'deleted_at',
+                          'deleted'])
+
+        file_attrs = base_attrs | set(['location', 'size'])
+        files = [_fetch_attrs(f, file_attrs) for f in image.files]
+
+        # TODO(sirp): should this be a dict, or a list of dicts?
+        # A plain dict is more convenient, but list of dicts would provide
+        # access to created_at, etc
+        metadata = dict((m.key, m.value) for m in image.metadata 
+                        if not m.deleted)
+
+        image_attrs = base_attrs | set(['name', 'image_type', 'state', 'public'])
+        
+        image_dict = _fetch_attrs(image, image_attrs)
+        image_dict['files'] = files
+        image_dict['metadata'] = metadata
+        return image_dict
+
+        return dict(id=image.id, 
+                    name=image.name,
+                    state=image.state,
+                    public=image.public,
+                    files=files,
+                    metadata=metadata)
+
+
+class API(wsgi.Router):
+    """WSGI entry point for all Parallax requests."""
+
+    def __init__(self):
+        # TODO(sirp): should we add back the middleware for parallax?
+        mapper = routes.Mapper()
+        mapper.resource("image", "images", controller=ImageController(),
+                        collection={'detail': 'GET'})
+        super(API, self).__init__(mapper)
+
+
+
+
+
+
+
+

=== added directory 'glance/parallax/db'
=== added file 'glance/parallax/db/__init__.py'
--- glance/parallax/db/__init__.py	1970-01-01 00:00:00 +0000
+++ glance/parallax/db/__init__.py	2010-10-01 23:24:45 +0000
@@ -0,0 +1,23 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+# 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.
+"""
+DB abstraction for Nova and Glance
+"""
+
+from glance.parallax.db.api import *

=== renamed file 'glance/common/db/api.py' => 'glance/parallax/db/api.py'
--- glance/common/db/api.py	2010-09-29 20:51:21 +0000
+++ glance/parallax/db/api.py	2010-10-01 23:24:45 +0000
@@ -30,7 +30,7 @@
 
 
 IMPL = utils.LazyPluggable(FLAGS['db_backend'],
-                           sqlalchemy='glance.common.db.sqlalchemy.api')
+                           sqlalchemy='glance.parallax.db.sqlalchemy.api')
 
 
 ###################
@@ -41,7 +41,6 @@
     return IMPL.image_create(context, values)
 
 
-
 def image_destroy(context, image_id):
     """Destroy the image or raise if it does not exist."""
     return IMPL.image_destroy(context, image_id)
@@ -57,6 +56,11 @@
     return IMPL.image_get_all(context)
 
 
+def image_get_all_public(context, public=True):
+    """Get all public images."""
+    return IMPL.image_get_all_public(context, public=public)
+
+
 def image_get_by_str(context, str_id):
     """Get an image by string id."""
     return IMPL.image_get_by_str(context, str_id)

=== added directory 'glance/parallax/db/sqlalchemy'
=== added file 'glance/parallax/db/sqlalchemy/__init__.py'
--- glance/parallax/db/sqlalchemy/__init__.py	1970-01-01 00:00:00 +0000
+++ glance/parallax/db/sqlalchemy/__init__.py	2010-10-01 23:24:45 +0000
@@ -0,0 +1,27 @@
+# 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.
+
+"""
+SQLAlchemy models for glance data
+"""
+
+from glance.parallax.db.sqlalchemy import models
+
+
+models.register_models()
+

=== renamed file 'glance/common/db/sqlalchemy/api.py' => 'glance/parallax/db/sqlalchemy/api.py'
--- glance/common/db/sqlalchemy/api.py	2010-09-29 20:51:21 +0000
+++ glance/parallax/db/sqlalchemy/api.py	2010-10-01 23:24:45 +0000
@@ -23,8 +23,8 @@
 from glance.common import db
 from glance.common import exception
 from glance.common import flags
-from glance.common.db.sqlalchemy import models
 from glance.common.db.sqlalchemy.session import get_session
+from glance.parallax.db.sqlalchemy import models
 from sqlalchemy.orm import exc
 
 #from sqlalchemy.orm import joinedload_all
@@ -78,16 +78,24 @@
     except exc.NoResultFound:
         new_exc = exception.NotFound("No model for id %s" % image_id)
         raise new_exc.__class__, new_exc, sys.exc_info()[2]
-    return models.Image.find(image_id, deleted=_deleted(context))
 
 
 def image_get_all(context):
     session = get_session()
-    # TODO(sirp): add back eager loading
-    return session.query(models.Image
-                 #).options(joinedload(models.Image.files)
-                 #).options(joinedload(models.Image.metadata)
-                 ).filter_by(deleted=_deleted(context)
+    return session.query(models.Image
+                 ).options(joinedload(models.Image.files)
+                 ).options(joinedload(models.Image.metadata)
+                 ).filter_by(deleted=_deleted(context)
+                 ).all()
+
+
+def image_get_all_public(context, public):
+    session = get_session()
+    return session.query(models.Image
+                 ).options(joinedload(models.Image.files)
+                 ).options(joinedload(models.Image.metadata)
+                 ).filter_by(deleted=_deleted(context)
+                 ).filter_by(public=public
                  ).all()
 
 

=== renamed file 'glance/common/db/sqlalchemy/models.py' => 'glance/parallax/db/sqlalchemy/models.py'
--- glance/common/db/sqlalchemy/models.py	2010-09-29 20:51:21 +0000
+++ glance/parallax/db/sqlalchemy/models.py	2010-10-01 23:24:45 +0000
@@ -173,7 +173,7 @@
 class ImageMetadatum(BASE, ModelBase):
     """Represents an image metadata in the datastore"""
     __tablename__ = 'image_metadata'
-    __prefix__ = 'mdata'
+    __prefix__ = 'img-meta'
     id = Column(Integer, primary_key=True)
     image_id = Column(Integer, ForeignKey('images.id'), nullable=False)
     image = relationship(Image, backref=backref('metadata'))

=== removed directory 'glance/teller/api'
=== removed file 'glance/teller/api/__init__.py'
=== removed file 'glance/teller/api/images.py'
--- glance/teller/api/images.py	2010-10-01 01:16:15 +0000
+++ glance/teller/api/images.py	1970-01-01 00:00:00 +0000
@@ -1,75 +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 glance.common import wsgi, db, exception
-from glance.teller.backends import get_from_backend
-from glance.teller.parallax import ParallaxAdapter
-from webob import exc, Response
-
-
-class Controller(wsgi.Controller):
-    """Image Controller """
-
-    image_lookup_fn = ParallaxAdapter.lookup
-
-    def index(self, request):
-        """ Get a list of images, does this even make sense? """
-        raise exc.HTTPNotImplemented
-
-    def detail(self, req):
-        """Detail is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def show(self, request, uri):
-        """
-        Query the parallax service for the image registry for the passed in 
-        request['uri']. If it exists, we connect to the appropriate backend as
-        determined by the URI scheme and yield chunks of data back to the
-        client. 
-        """
-
-        #info(twitch) I don't know if this would actually happen in the wild.
-        if uri is None:
-            return exc.HTTPBadRequest(body="Missing uri", request=request,
-                                      content_type="text/plain")
-
-        image = self.image_lookup_fn(uri)
-        if not image:
-            raise exc.HTTPNotFound(body='Image not found', request=request,
-                                   content_type='text/plain')
-
-        def image_iterator():
-            for file in image['files']:
-                for chunk in get_from_backend(file['location'], 
-                                              expected_size=file['size']):
-                    yield chunk
-
-
-        return request.get_response(Response(app_iter=image_iterator()))
-
-    def delete(self, req, id):
-        """Delete is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def create(self, req):
-        """Create is not currently supported """
-        raise exc.HTTPNotImplemented()
-
-    def update(self, req, id):
-        """Update is not currently supported """
-        raise exc.HTTPNotImplemented()
-

=== modified file 'glance/teller/backends.py'
--- glance/teller/backends.py	2010-09-28 20:18:30 +0000
+++ glance/teller/backends.py	2010-10-01 23:24:45 +0000
@@ -21,6 +21,14 @@
 import urlparse
 
 
+def _file_iter(f, size):
+    """ Return an iterator for a file-like object """
+    chunk = f.read(size)
+    while chunk:
+        yield chunk
+        chunk = f.read(size)
+
+
 class BackendException(Exception):
     pass
 
@@ -53,19 +61,18 @@
             return p
 
         with opener(sanitize_path(parsed_uri.path)) as f:
-            chunk = f.read(cls.CHUNKSIZE)
-            while chunk:
-                yield chunk
-                chunk = f.read(cls.CHUNKSIZE)
+            return _file_iter(f, cls.CHUNKSIZE)
          
 
 class HTTPBackend(Backend):
+    """ An implementation of the HTTP Backend Adapter """
+
     @classmethod
     def get(cls, parsed_uri, expected_size, conn_class=None):
-        """
-        http://netloc/path/to/file.tar.gz.0
-        https://netloc/path/to/file.tar.gz.0
-        """
+        """Takes a parsed uri for an HTTP resource, fetches it, ane yields the
+        data.
+        """
+
         if conn_class:
             pass # use the conn_class passed in
         elif parsed_uri.scheme == "http":
@@ -74,14 +81,12 @@
             conn_class = httplib.HTTPSConnection
         else:
             raise BackendException("scheme '%s' not supported for HTTPBackend")
+        
         conn = conn_class(parsed_uri.netloc)
         conn.request("GET", parsed_uri.path, "", {})
+        
         try:
-            response = conn.getresponse()
-            chunk = response.read(cls.CHUNKSIZE)
-            while chunk:
-                yield chunk
-                chunk = response.read(cls.CHUNKSIZE)
+            return _file_iter(conn.getresponse(), cls.CHUNKSIZE)
         finally:
             conn.close()
 
@@ -130,24 +135,22 @@
                                    % (expected_size, obj.size))
 
 
-def _scheme2backend(scheme):
-    return {
-        "file": FilesystemBackend,
-        "http": HTTPBackend,
-        "https": HTTPBackend,
-        "swift": SwiftBackend,
-        "teststr": TestStrBackend
-    }[scheme]
-
+BACKENDS = {
+    "file": FilesystemBackend,
+    "http": HTTPBackend,
+    "https": HTTPBackend,
+    "swift": SwiftBackend,
+    "teststr": TestStrBackend
+}
 
 def get_from_backend(uri, **kwargs):
-    """
-    Yields chunks of data from backend specified by uri
-    """
+    """ Yields chunks of data from backend specified by uri """
     parsed_uri = urlparse.urlparse(uri)
+
     try:
-        return _scheme2backend(parsed_uri.scheme).get(parsed_uri, **kwargs)
+        backend = BACKENDS[parsed_uri.scheme]
     except KeyError:
         raise UnsupportedBackend("No backend found for '%s'" % parsed_uri.scheme)
 
+    return backend.get(parsed_uri, **kwargs)
 

=== added file 'glance/teller/controllers.py'
--- glance/teller/controllers.py	1970-01-01 00:00:00 +0000
+++ glance/teller/controllers.py	2010-10-01 23:24:45 +0000
@@ -0,0 +1,109 @@
+# 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.
+"""
+Teller Image controller
+"""
+
+import routes
+from webob import exc, Response
+from glance.common import wsgi
+from glance.common import exception
+from glance.parallax import db
+from glance.teller import backends
+from glance.teller import registries
+
+
+class ImageController(wsgi.Controller):
+    """Image Controller """
+
+    def index(self, req):
+        """
+        Query the parallax service for the image registry for the passed in 
+        req['uri']. If it exists, we connect to the appropriate backend as
+        determined by the URI scheme and yield chunks of data back to the
+        client. 
+
+        Optionally, we can pass in 'registry' which will use a given
+        RegistryAdapter for the request. This is useful for testing.
+        """
+        try:
+            uri = req.str_GET['uri']
+        except KeyError:
+            return exc.HTTPBadRequest(body="Missing uri", request=req,
+                                      content_type="text/plain")
+
+        registry = req.str_GET.get('registry', 'parallax')
+
+        try:
+            image = registries.lookup_by_registry(registry, uri)
+        except registries.UnknownRegistryAdapter:
+            return exc.HTTPBadRequest(body="Uknown registry '%s'" % registry,
+                                      request=req,
+                                      content_type="text/plain")
+
+        if not image:
+            raise exc.HTTPNotFound(body='Image not found', request=req,
+                                   content_type='text/plain')
+
+        def image_iterator():
+            for file in image['files']:
+                chunks = backends.get_from_backend(
+                    file['location'], expected_size=file['size'])
+
+                for chunk in chunks:
+                    yield chunk
+
+
+        return req.get_response(Response(app_iter=image_iterator()))
+    
+    def detail(self, req):
+        """Detail is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def show(self, req):
+        """Show is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def delete(self, req, id):
+        """Delete is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def create(self, req):
+        """Create is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+    def update(self, req, id):
+        """Update is not currently supported """
+        raise exc.HTTPNotImplemented()
+
+
+class API(wsgi.Router):
+    """WSGI entry point for all Parallax requests."""
+
+    def __init__(self):
+        mapper = routes.Mapper()
+        mapper.resource("image", "image", controller=ImageController(),
+                        collection={'detail': 'GET'})
+        super(API, self).__init__(mapper)
+
+
+
+
+
+
+
+

=== renamed file 'glance/teller/parallax.py' => 'glance/teller/registries.py'
--- glance/teller/parallax.py	2010-10-01 01:16:15 +0000
+++ glance/teller/registries.py	2010-10-01 23:24:45 +0000
@@ -20,7 +20,28 @@
 import urlparse
 
 
-class ParallaxAdapter(object):
+class RegistryAdapterException(Exception):
+    """ Base class for all RegistryAdapter exceptions """
+    pass
+
+
+class UnknownRegistryAdapter(RegistryAdapterException):
+    """ Raised if we don't recognize the requested Registry protocol """
+    pass
+
+
+class RegistryAdapter(object):
+    """ Base class for all image endpoints """
+
+    @classmethod
+    def lookup(cls, image_uri):
+        """ Subclasses must define a lookup method which returns an dictionary
+        representing the image.
+        """
+        raise NotImplementedError
+
+
+class ParallaxAdapter(RegistryAdapter):
     """
     ParallaxAdapter stuff
     """
@@ -47,9 +68,13 @@
             # The image exists
             if response.status == 200: 
                 result = response.read()
+                image_json = json.loads(result)
+                
+                try:
+                    return image_json["image"]
+                except KeyError:
+                    raise RegistryAdapterException("Missing 'image' key")
 
-                json = json.loads(result)
-                return json
         finally:
             conn.close()
 
@@ -63,10 +88,25 @@
     def lookup(cls, image_uri):
         if image_uri.count("success"):
             # A successful attempt
-            mock_res = { "files":[{"location":"teststr://chunk0", 
-                                   "size":1235},
-                                  {"location": "teststr://chunk1", 
-                                   "size":12345}]}
+            files = [dict(location="teststr://chunk0", size=1235),
+                     dict(location="teststr://chunk1", size=12345)]
+            
+            mock_res = dict(files=files)
+            
             return mock_res
 
+REGISTRY_ADAPTERS = {
+    'parallax': ParallaxAdapter,
+    'fake_parallax': FakeParallaxAdapter
+}
+
+def lookup_by_registry(registry, image_uri):
+    """ Convenience function to lookup based on a registry protocol """
+    try:
+        adapter = REGISTRY_ADAPTERS[registry]
+    except KeyError:
+        raise UnknownRegistryAdapter("'%s' not found" % registry)
+    
+    return adapter.lookup(image_uri)
+
 

=== modified file 'tests/test_data.py'
--- tests/test_data.py	2010-09-29 20:51:21 +0000
+++ tests/test_data.py	2010-10-01 23:24:45 +0000
@@ -15,30 +15,30 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from glance.common.db import api
+from glance.parallax import db
 
 
 def make_fake_image():
     """Create a fake image record """
-    image = api.image_create(
+    image = db.image_create(
         None,
         dict(name="Test Image",
              state="available",
              public=True,
              image_type="tarball"))
 
-    api.image_file_create(
-        None, 
-        dict(image_id=image.id,
-             location="swift://myacct/mycontainer/obj.tar.gz.0",
-             size=101))
-    api.image_file_create(
-        None, 
-        dict(image_id=image.id,
-             location="swift://myacct/mycontainer/obj.tar.gz.1",
-             size=101))
+    db.image_file_create(
+        None, 
+        dict(image_id=image.id,
+             location="teststr://chunk0",
+             size=6))
+    db.image_file_create(
+        None, 
+        dict(image_id=image.id,
+             location="teststr://chunk1",
+             size=6))
 
-    api.image_metadatum_create(
+    db.image_metadatum_create(
         None,
         dict(image_id=image.id,
              key="testkey",

=== modified file 'tests/unit/test_teller_api.py'
--- tests/unit/test_teller_api.py	2010-10-01 01:16:15 +0000
+++ tests/unit/test_teller_api.py	2010-10-01 23:24:45 +0000
@@ -1,33 +1,41 @@
 import unittest
 from webob import Request, exc
-from glance.teller import parallax
-from glance.teller.api import images as image_server
+from glance.teller import controllers
 
 class TestImageController(unittest.TestCase):
     def setUp(self):
-        fake_parallax = parallax.FakeParallaxAdapter
-
-        self.image_controller = image_server.Controller()
-        self.image_controller.image_lookup_fn = fake_parallax.lookup
-
-    def test_show_image_with_no_uri_should_raise_http_bad_request(self):
+        self.image_controller = controllers.ImageController()
+
+    def test_index_image_with_no_uri_should_raise_http_bad_request(self):
         # uri must be specified
         request = Request.blank("/image")
-        response = self.image_controller.show(request, None)
-        self.assertEqual(response.status_int, 400) # should be 422?
-
-    def test_show_image_where_image_exists_should_return_the_data(self):
-        # FIXME: need urllib.quote here?
-        image_uri = "http://parallax-success/myacct/my-image"
-        request = Request.blank("/image?uri=%s" % image_uri)
-        response = self.image_controller.show(request, image_uri)
+        response = self.image_controller.index(request)
+        self.assertEqual(response.status_int, 400) # should be 422?
+
+    def test_index_image_unrecognized_registry_adapter(self):
+        # FIXME: need urllib.quote here?
+        image_uri = "http://parallax-success/myacct/my-image"
+        request = self._make_request(image_uri, "unknownregistry")
+        response = self.image_controller.index(request)
+        self.assertEqual(response.status_int, 400) # should be 422?
+
+    def test_index_image_where_image_exists_should_return_the_data(self):
+        # FIXME: need urllib.quote here?
+        image_uri = "http://parallax-success/myacct/my-image"
+        request = self._make_request(image_uri)
+        response = self.image_controller.index(request)
         self.assertEqual("//chunk0//chunk1", response.body)
 
-    def test_show_image_where_image_doesnt_exist_should_raise_not_found(self):
+    def test_index_image_where_image_doesnt_exist_should_raise_not_found(self):
         image_uri = "http://parallax-failure/myacct/does-not-exist"
-        request = Request.blank("/image?uri=%s" % image_uri)
-        self.assertRaises(exc.HTTPNotFound, self.image_controller.show, request,
-                          image_uri)
+        request = self._make_request(image_uri)
+        self.assertRaises(exc.HTTPNotFound, self.image_controller.index,
+                          request)
+
+    def _make_request(self, image_uri, registry="fake_parallax"):
+        return Request.blank(
+            "/image?uri=%s&registry=%s" % (image_uri, registry))
+
 
 if __name__ == "__main__":
     unittest.main()