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

[Rick Harris]

This patch:
  * pulls in a number of useful libraries from Nova under the common/ path (we can factor those out to a shared library in Bexar-release)
  * Defines the models in common.db.sqlalchemy.models.py (this should be factored out into the parallax package soon)
  * Adds the parallax api-server under /bin (if PyPI was used to pull python-daemon and python-lockfile, you may need to apply a patch I have against it)

[Christopher MacGown (0x44)]

lgtm

review: Approve

[Christopher MacGown (0x44)]

Actually, hold that. In the below, any instance of chunk_dicts and chunk should be replaced by file, since they're the files that make up an image. Teller uses the term 'chunk' to mean an arbitrary sized piece of the read file buffer yielded to the requester.

82 + chunk_dicts = []
1683 + for chunk in image.image_chunks:
1684 + chunk_dict = dict(location=chunk.location, size=chunk.size)
1685 + chunk_dicts.append(chunk_dict)
1686 +
1687 + metadata_dicts = []
1688 + for metadatum in image.image_metadata:
1689 + metadatum_dict = dict(key=metadatum.key, value=metadatum.value)
1690 + metadata_dicts.append(metadatum_dict)
1691 +
1692 + image_dict = dict(id=image.id, name=image.name, state=image.state,
1693 + public=image.public, chunks=chunk_dicts,

review: Needs Fixing

[Jay Pipes (jaypipes)]

Looks good! We can refactor the common stuff into openstack-common after Austin, of course.

The only suggestion I have is to combine the glance.parallax.api.API and glance.parallax.api.APIRouter class into a single class. wsgi.Router *is* middleware (since its constructor sets routes.RoutesMiddleware as the application to return, and its __call__ method returns that application, so unless I'm mistaken, the following code should work fine:

class API(wsgi.Router):
    """
    Routes requests on the Parallax to the appropriate controller
    and method.
    """

    def __init__(self):
        mapper = routes.Mapper()
        mapper.resource("image", "images", controller=images.Controller(),
            collection={'detail': 'GET'})
        super(APIRouter, self).__init__(mapper)

Cheers!
jay

[Jay Pipes (jaypipes)]

s/super(APIRouter/super(API/

in the code above.

[lp:~rconradharris/glance/lp615675]

12. By Rick Harris on 2010-09-29

ImageChunk -> ImageFile, merging APIRouter into API for now

[Christopher MacGown (0x44)]

Awesome.

review: Approve

=== added file 'bin/parallax-server.py'
--- bin/parallax-server.py	1970-01-01 00:00:00 +0000
+++ bin/parallax-server.py	2010-09-29 20:56:47 +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.
+"""
+Parallax 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, 'parallax', '__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.parallax import api
+
+
+FLAGS = flags.FLAGS
+# TODO(sirp): ensure no conflicts in port selection
+flags.DEFINE_integer('parallax_port', 9191, 'Parallax port')
+
+def main(_args):
+    wsgi.run_server(api.API(), FLAGS.parallax_port)
+
+if __name__ == '__main__':
+    utils.default_flagfile()
+    server.serve('parallax-server', main)

=== added directory 'glance/common'
=== added file 'glance/common/__init__.py'
=== added directory 'glance/common/db'
=== added file 'glance/common/db/__init__.py'
--- glance/common/db/__init__.py	1970-01-01 00:00:00 +0000
+++ glance/common/db/__init__.py	2010-09-29 20:56:47 +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.common.db.api import *

=== added file 'glance/common/db/api.py'
--- glance/common/db/api.py	1970-01-01 00:00:00 +0000
+++ glance/common/db/api.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,88 @@
+# 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.
+"""
+Defines interface for DB access
+"""
+
+from glance.common import exception
+from glance.common import flags
+from glance.common import utils
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('db_backend', 'sqlalchemy',
+                    'The backend to use for db')
+
+
+IMPL = utils.LazyPluggable(FLAGS['db_backend'],
+                           sqlalchemy='glance.common.db.sqlalchemy.api')
+
+
+###################
+
+
+def image_create(context, values):
+    """Create an image from the values dictionary."""
+    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)
+
+
+def image_get(context, image_id):
+    """Get an image or raise if it does not exist."""
+    return IMPL.image_get(context, image_id)
+
+
+def image_get_all(context):
+    """Get all images."""
+    return IMPL.image_get_all(context)
+
+
+def image_get_by_str(context, str_id):
+    """Get an image by string id."""
+    return IMPL.image_get_by_str(context, str_id)
+
+
+def image_update(context, image_id, values):
+    """Set the given properties on an image and update it.
+
+    Raises NotFound if image does not exist.
+
+    """
+    return IMPL.image_update(context, image_id, values)
+
+
+###################
+
+
+def image_file_create(context, values):
+    """Create an image file from the values dictionary."""
+    return IMPL.image_file_create(context, values)
+
+
+###################
+
+
+def image_metadatum_create(context, values):
+    """Create an image metadatum from the values dictionary."""
+    return IMPL.image_metadatum_create(context, values)
+

=== added directory 'glance/common/db/sqlalchemy'
=== added file 'glance/common/db/sqlalchemy/__init__.py'
--- glance/common/db/sqlalchemy/__init__.py	1970-01-01 00:00:00 +0000
+++ glance/common/db/sqlalchemy/__init__.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,24 @@
+# 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()

=== added file 'glance/common/db/sqlalchemy/api.py'
--- glance/common/db/sqlalchemy/api.py	1970-01-01 00:00:00 +0000
+++ glance/common/db/sqlalchemy/api.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,127 @@
+# 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.
+"""
+Implementation of SQLAlchemy backend
+"""
+
+import sys
+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 sqlalchemy.orm import exc
+
+#from sqlalchemy.orm import joinedload_all
+# TODO(sirp): add back eager loading
+from sqlalchemy.orm import joinedload
+from sqlalchemy.sql import func
+
+FLAGS = flags.FLAGS
+
+
+# NOTE(vish): disabling docstring pylint because the docstrings are
+#             in the interface definition
+# pylint: disable-msg=C0111
+def _deleted(context):
+    """Calculates whether to include deleted objects based on context.
+
+    Currently just looks for a flag called deleted in the context dict.
+    """
+    if not hasattr(context, 'get'):
+        return False
+    return context.get('deleted', False)
+
+
+###################
+
+
+def image_create(_context, values):
+    image_ref = models.Image()
+    for (key, value) in values.iteritems():
+        image_ref[key] = value
+    image_ref.save()
+    return image_ref
+
+
+def image_destroy(_context, image_id):
+    session = get_session()
+    with session.begin():
+        image_ref = models.Image.find(image_id, session=session)
+        image_ref.delete(session=session)
+
+
+def image_get(context, image_id):
+    session = get_session()
+    try:
+        return session.query(models.Image
+                     ).options(joinedload(models.Image.files)
+                     ).options(joinedload(models.Image.metadata)
+                     ).filter_by(deleted=_deleted(context)
+                     ).filter_by(id=image_id
+                     ).one()
+    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)
+                 ).all()
+
+
+def image_get_by_str(context, str_id):
+    return models.Image.find_by_str(str_id, deleted=_deleted(context))
+
+
+def image_update(_context, image_id, values):
+    session = get_session()
+    with session.begin():
+        image_ref = models.Image.find(image_id, session=session)
+        for (key, value) in values.iteritems():
+            image_ref[key] = value
+        image_ref.save(session=session)
+
+
+###################
+
+
+def image_file_create(_context, values):
+    image_file_ref = models.ImageFile()
+    for (key, value) in values.iteritems():
+        image_file_ref[key] = value
+    image_file_ref.save()
+    return image_file_ref
+
+
+###################
+
+
+def image_metadatum_create(_context, values):
+    image_metadatum_ref = models.ImageMetadatum()
+    for (key, value) in values.iteritems():
+        image_metadatum_ref[key] = value
+    image_metadatum_ref.save()
+    return image_metadatum_ref
+

=== added file 'glance/common/db/sqlalchemy/models.py'
--- glance/common/db/sqlalchemy/models.py	1970-01-01 00:00:00 +0000
+++ glance/common/db/sqlalchemy/models.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,191 @@
+# 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
+"""
+
+import sys
+import datetime
+
+# TODO(vish): clean up these imports
+from sqlalchemy.orm import relationship, backref, exc, object_mapper
+from sqlalchemy import Column, Integer, String
+from sqlalchemy import ForeignKey, DateTime, Boolean, Text
+from sqlalchemy.ext.declarative import declarative_base
+
+from glance.common.db.sqlalchemy.session import get_session
+
+# FIXME(sirp): confirm this is not needed
+#from common import auth
+from glance.common import exception
+from glance.common import flags
+
+FLAGS = flags.FLAGS
+
+BASE = declarative_base()
+
+#TODO(sirp): ModelBase should be moved out so Glance and Nova can share it
+class ModelBase(object):
+    """Base class for Nova and Glance Models"""
+    __table_args__ = {'mysql_engine': 'InnoDB'}
+    __table_initialized__ = False
+    __prefix__ = 'none'
+    created_at = Column(DateTime, default=datetime.datetime.utcnow)
+    updated_at = Column(DateTime, onupdate=datetime.datetime.utcnow)
+    deleted_at = Column(DateTime)
+    deleted = Column(Boolean, default=False)
+
+    @classmethod
+    def all(cls, session=None, deleted=False):
+        """Get all objects of this type"""
+        if not session:
+            session = get_session()
+        return session.query(cls
+                     ).filter_by(deleted=deleted
+                     ).all()
+
+    @classmethod
+    def count(cls, session=None, deleted=False):
+        """Count objects of this type"""
+        if not session:
+            session = get_session()
+        return session.query(cls
+                     ).filter_by(deleted=deleted
+                     ).count()
+
+    @classmethod
+    def find(cls, obj_id, session=None, deleted=False):
+        """Find object by id"""
+        if not session:
+            session = get_session()
+        try:
+            return session.query(cls
+                         ).filter_by(id=obj_id
+                         ).filter_by(deleted=deleted
+                         ).one()
+        except exc.NoResultFound:
+            new_exc = exception.NotFound("No model for id %s" % obj_id)
+            raise new_exc.__class__, new_exc, sys.exc_info()[2]
+
+    @classmethod
+    def find_by_str(cls, str_id, session=None, deleted=False):
+        """Find object by str_id"""
+        int_id = int(str_id.rpartition('-')[2])
+        return cls.find(int_id, session=session, deleted=deleted)
+
+    @property
+    def str_id(self):
+        """Get string id of object (generally prefix + '-' + id)"""
+        return "%s-%s" % (self.__prefix__, self.id)
+
+    def save(self, session=None):
+        """Save this object"""
+        if not session:
+            session = get_session()
+        session.add(self)
+        session.flush()
+
+    def delete(self, session=None):
+        """Delete this object"""
+        self.deleted = True
+        self.deleted_at = datetime.datetime.utcnow()
+        self.save(session=session)
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __iter__(self):
+        self._i = iter(object_mapper(self).columns)
+        return self
+
+    def next(self):
+        n = self._i.next().name
+        return n, getattr(self, n)
+
+class Image(BASE, ModelBase):
+    """Represents an image in the datastore"""
+    __tablename__ = 'images'
+    __prefix__ = 'img'
+    
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255))
+    image_type = Column(String(255))
+    state = Column(String(255))
+    public = Column(Boolean, default=False)
+
+    #@validates('image_type')
+    #def validate_image_type(self, key, image_type):
+    #    assert(image_type in ('machine', 'kernel', 'ramdisk', 'raw'))
+    #
+    #@validates('state')
+    #def validate_state(self, key, state):
+    #    assert(state in ('available', 'pending', 'disabled'))
+    #
+    # TODO(sirp): should these be stored as metadata?
+    #user_id = Column(String(255))
+    #project_id = Column(String(255))
+    #arch = Column(String(255))
+    #default_kernel_id = Column(String(255))
+    #default_ramdisk_id = Column(String(255))
+    #
+    #@validates('default_kernel_id')
+    #def validate_kernel_id(self, key, val):
+    #    if val != 'machine':
+    #        assert(val is None)
+    # 
+    #@validates('default_ramdisk_id')
+    #def validate_ramdisk_id(self, key, val):
+    #    if val != 'machine':
+    #        assert(val is None)
+
+
+class ImageFile(BASE, ModelBase):
+    """Represents an image file in the datastore"""
+    __tablename__ = 'image_files'
+    __prefix__ = 'img-file'
+    id = Column(Integer, primary_key=True)
+    image_id = Column(Integer, ForeignKey('images.id'), nullable=False)
+    image = relationship(Image, backref=backref('files'))
+
+    location = Column(String(255))
+    size = Column(Integer)
+
+
+class ImageMetadatum(BASE, ModelBase):
+    """Represents an image metadata in the datastore"""
+    __tablename__ = 'image_metadata'
+    __prefix__ = 'mdata'
+    id = Column(Integer, primary_key=True)
+    image_id = Column(Integer, ForeignKey('images.id'), nullable=False)
+    image = relationship(Image, backref=backref('metadata'))
+    
+    key = Column(String(255), index=True, unique=True)
+    value = Column(Text)
+
+
+def register_models():
+    """Register Models and create metadata"""
+    from sqlalchemy import create_engine
+    models = (Image, ImageFile, ImageMetadatum)
+    engine = create_engine(FLAGS.sql_connection, echo=False)
+    for model in models:
+        model.metadata.create_all(engine)

=== added file 'glance/common/db/sqlalchemy/session.py'
--- glance/common/db/sqlalchemy/session.py	1970-01-01 00:00:00 +0000
+++ glance/common/db/sqlalchemy/session.py	2010-09-29 20:56:47 +0000
@@ -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.
+"""
+Session Handling for SQLAlchemy backend
+"""
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from glance.common import flags
+
+FLAGS = flags.FLAGS
+
+_ENGINE = None
+_MAKER = None
+
+def get_session(autocommit=True, expire_on_commit=False):
+    """Helper method to grab session"""
+    global _ENGINE
+    global _MAKER
+    if not _MAKER:
+        if not _ENGINE:
+            _ENGINE = create_engine(FLAGS.sql_connection, echo=False)
+        _MAKER = sessionmaker(bind=_ENGINE,
+                              autocommit=autocommit,
+                              expire_on_commit=expire_on_commit)
+    return _MAKER()

=== added file 'glance/common/exception.py'
--- glance/common/exception.py	1970-01-01 00:00:00 +0000
+++ glance/common/exception.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,87 @@
+# 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.
+
+"""
+Nova base exception handling, including decorator for re-raising
+Nova-type exceptions. SHOULD include dedicated exception logging.
+"""
+
+import logging
+import sys
+import traceback
+
+
+class ProcessExecutionError(IOError):
+    def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None,
+                 description=None):
+        if description is None:
+            description = "Unexpected error while running command."
+        if exit_code is None:
+            exit_code = '-'
+        message = "%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r" % (
+                  description, cmd, exit_code, stdout, stderr)
+        IOError.__init__(self, message)
+
+
+class Error(Exception):
+    def __init__(self, message=None):
+        super(Error, self).__init__(message)
+
+
+class ApiError(Error):
+    def __init__(self, message='Unknown', code='Unknown'):
+        self.message = message
+        self.code = code
+        super(ApiError, self).__init__('%s: %s'% (code, message))
+
+
+class NotFound(Error):
+    pass
+
+
+class Duplicate(Error):
+    pass
+
+
+class NotAuthorized(Error):
+    pass
+
+
+class NotEmpty(Error):
+    pass
+
+
+class Invalid(Error):
+    pass
+
+
+def wrap_exception(f):
+    def _wrap(*args, **kw):
+        try:
+            return f(*args, **kw)
+        except Exception, e:
+            if not isinstance(e, Error):
+                #exc_type, exc_value, exc_traceback = sys.exc_info()
+                logging.exception('Uncaught exception')
+                #logging.error(traceback.extract_stack(exc_traceback))
+                raise Error(str(e))
+            raise
+    _wrap.func_name = f.func_name
+    return _wrap
+
+

=== added file 'glance/common/flags.py'
--- glance/common/flags.py	1970-01-01 00:00:00 +0000
+++ glance/common/flags.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,175 @@
+# 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.
+
+"""
+Package-level global flags are defined here, the rest are defined
+where they're used.
+"""
+
+import getopt
+import os
+import socket
+import sys
+
+import gflags
+
+
+class FlagValues(gflags.FlagValues):
+    """Extension of gflags.FlagValues that allows undefined and runtime flags.
+
+    Unknown flags will be ignored when parsing the command line, but the
+    command line will be kept so that it can be replayed if new flags are
+    defined after the initial parsing.
+
+    """
+
+    def __init__(self):
+        gflags.FlagValues.__init__(self)
+        self.__dict__['__dirty'] = []
+        self.__dict__['__was_already_parsed'] = False
+        self.__dict__['__stored_argv'] = []
+
+    def __call__(self, argv):
+        # We're doing some hacky stuff here so that we don't have to copy
+        # out all the code of the original verbatim and then tweak a few lines.
+        # We're hijacking the output of getopt so we can still return the
+        # leftover args at the end
+        sneaky_unparsed_args = {"value": None}
+        original_argv = list(argv)
+
+        if self.IsGnuGetOpt():
+            orig_getopt = getattr(getopt, 'gnu_getopt')
+            orig_name = 'gnu_getopt'
+        else:
+            orig_getopt = getattr(getopt, 'getopt')
+            orig_name = 'getopt'
+
+        def _sneaky(*args, **kw):
+            optlist, unparsed_args = orig_getopt(*args, **kw)
+            sneaky_unparsed_args['value'] = unparsed_args
+            return optlist, unparsed_args
+
+        try:
+            setattr(getopt, orig_name, _sneaky)
+            args = gflags.FlagValues.__call__(self, argv)
+        except gflags.UnrecognizedFlagError:
+            # Undefined args were found, for now we don't care so just
+            # act like everything went well
+            # (these three lines are copied pretty much verbatim from the end
+            # of the __call__ function we are wrapping)
+            unparsed_args = sneaky_unparsed_args['value']
+            if unparsed_args:
+                if self.IsGnuGetOpt():
+                    args = argv[:1] + unparsed_args
+                else:
+                    args = argv[:1] + original_argv[-len(unparsed_args):]
+            else:
+                args = argv[:1]
+        finally:
+            setattr(getopt, orig_name, orig_getopt)
+
+        # Store the arguments for later, we'll need them for new flags
+        # added at runtime
+        self.__dict__['__stored_argv'] = original_argv
+        self.__dict__['__was_already_parsed'] = True
+        self.ClearDirty()
+        return args
+
+    def SetDirty(self, name):
+        """Mark a flag as dirty so that accessing it will case a reparse."""
+        self.__dict__['__dirty'].append(name)
+
+    def IsDirty(self, name):
+        return name in self.__dict__['__dirty']
+
+    def ClearDirty(self):
+        self.__dict__['__is_dirty'] = []
+
+    def WasAlreadyParsed(self):
+        return self.__dict__['__was_already_parsed']
+
+    def ParseNewFlags(self):
+        if '__stored_argv' not in self.__dict__:
+            return
+        new_flags = FlagValues()
+        for k in self.__dict__['__dirty']:
+            new_flags[k] = gflags.FlagValues.__getitem__(self, k)
+
+        new_flags(self.__dict__['__stored_argv'])
+        for k in self.__dict__['__dirty']:
+            setattr(self, k, getattr(new_flags, k))
+        self.ClearDirty()
+
+    def __setitem__(self, name, flag):
+        gflags.FlagValues.__setitem__(self, name, flag)
+        if self.WasAlreadyParsed():
+            self.SetDirty(name)
+
+    def __getitem__(self, name):
+        if self.IsDirty(name):
+            self.ParseNewFlags()
+        return gflags.FlagValues.__getitem__(self, name)
+
+    def __getattr__(self, name):
+        if self.IsDirty(name):
+            self.ParseNewFlags()
+        return gflags.FlagValues.__getattr__(self, name)
+
+
+FLAGS = FlagValues()
+
+
+def _wrapper(func):
+    def _wrapped(*args, **kw):
+        kw.setdefault('flag_values', FLAGS)
+        func(*args, **kw)
+    _wrapped.func_name = func.func_name
+    return _wrapped
+
+
+DEFINE = _wrapper(gflags.DEFINE)
+DEFINE_string = _wrapper(gflags.DEFINE_string)
+DEFINE_integer = _wrapper(gflags.DEFINE_integer)
+DEFINE_bool = _wrapper(gflags.DEFINE_bool)
+DEFINE_boolean = _wrapper(gflags.DEFINE_boolean)
+DEFINE_float = _wrapper(gflags.DEFINE_float)
+DEFINE_enum = _wrapper(gflags.DEFINE_enum)
+DEFINE_list = _wrapper(gflags.DEFINE_list)
+DEFINE_spaceseplist = _wrapper(gflags.DEFINE_spaceseplist)
+DEFINE_multistring = _wrapper(gflags.DEFINE_multistring)
+DEFINE_multi_int = _wrapper(gflags.DEFINE_multi_int)
+
+
+def DECLARE(name, module_string, flag_values=FLAGS):
+    if module_string not in sys.modules:
+        __import__(module_string, globals(), locals())
+    if name not in flag_values:
+        raise gflags.UnrecognizedFlag(
+                "%s not defined by %s" % (name, module_string))
+
+
+# __GLOBAL FLAGS ONLY__
+# Define any app-specific flags in their own files, docs at:
+# http://code.google.com/p/python-gflags/source/browse/trunk/gflags.py#39
+
+# TODO(sirp): move this out to an application specific setting when we create
+# Nova/Glance common library
+DEFINE_string('sql_connection',
+              'sqlite:///%s/glance.sqlite' % os.path.abspath("./"),
+              'connection string for sql database')
+DEFINE_bool('verbose', False, 'show debug output')

=== added file 'glance/common/server.py'
--- glance/common/server.py	1970-01-01 00:00:00 +0000
+++ glance/common/server.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,144 @@
+# 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.
+
+"""
+Base functionality for nova daemons - gradually being replaced with twistd.py.
+"""
+
+import daemon
+from daemon import pidlockfile
+import logging
+import logging.handlers
+import os
+import signal
+import sys
+import time
+
+from glance.common import flags
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_bool('daemonize', False, 'daemonize this process')
+# NOTE(termie): right now I am defaulting to using syslog when we daemonize
+#               it may be better to do something else -shrug-
+# NOTE(Devin): I think we should let each process have its own log file
+#              and put it in /var/logs/nova/(appname).log
+#              This makes debugging much easier and cuts down on sys log
+#              clutter.
+flags.DEFINE_bool('use_syslog', True, 'output to syslog when daemonizing')
+flags.DEFINE_string('logfile', None, 'log file to output to')
+flags.DEFINE_string('pidfile', None, 'pid file to output to')
+flags.DEFINE_string('working_directory', './', 'working directory...')
+flags.DEFINE_integer('uid', os.getuid(), 'uid under which to run')
+flags.DEFINE_integer('gid', os.getgid(), 'gid under which to run')
+
+
+def stop(pidfile):
+    """
+    Stop the daemon
+    """
+    # Get the pid from the pidfile
+    try:
+        pid = int(open(pidfile,'r').read().strip())
+    except IOError:
+        message = "pidfile %s does not exist. Daemon not running?\n"
+        sys.stderr.write(message % pidfile)
+        return # not an error in a restart
+
+    # Try killing the daemon process
+    try:
+        while 1:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(0.1)
+    except OSError, err:
+        err = str(err)
+        if err.find("No such process") > 0:
+            if os.path.exists(pidfile):
+                os.remove(pidfile)
+        else:
+            print str(err)
+            sys.exit(1)
+
+
+def serve(name, main):
+    """Controller for server"""
+    argv = FLAGS(sys.argv)
+
+    if not FLAGS.pidfile:
+        FLAGS.pidfile = '%s.pid' % name
+
+    logging.debug("Full set of FLAGS: \n\n\n")
+    for flag in FLAGS:
+        logging.debug("%s : %s", flag, FLAGS.get(flag, None))
+
+    action = 'start'
+    if len(argv) > 1:
+        action = argv.pop()
+
+    if action == 'stop':
+        stop(FLAGS.pidfile)
+        sys.exit()
+    elif action == 'restart':
+        stop(FLAGS.pidfile)
+    elif action == 'start':
+        pass
+    else:
+        print 'usage: %s [options] [start|stop|restart]' % argv[0]
+        sys.exit(1)
+    daemonize(argv, name, main)
+
+
+def daemonize(args, name, main):
+    """Does the work of daemonizing the process"""
+    logging.getLogger('amqplib').setLevel(logging.WARN)
+    if FLAGS.daemonize:
+        logger = logging.getLogger()
+        formatter = logging.Formatter(
+                name + '(%(name)s): %(levelname)s %(message)s')
+        if FLAGS.use_syslog and not FLAGS.logfile:
+            syslog = logging.handlers.SysLogHandler(address='/dev/log')
+            syslog.setFormatter(formatter)
+            logger.addHandler(syslog)
+        else:
+            if not FLAGS.logfile:
+                FLAGS.logfile = '%s.log' % name
+            logfile = logging.FileHandler(FLAGS.logfile)
+            logfile.setFormatter(formatter)
+            logger.addHandler(logfile)
+        stdin, stdout, stderr = None, None, None
+    else:
+        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
+
+    if FLAGS.verbose:
+        logging.getLogger().setLevel(logging.DEBUG)
+    else:
+        logging.getLogger().setLevel(logging.WARNING)
+
+    with daemon.DaemonContext(
+            detach_process=FLAGS.daemonize,
+            working_directory=FLAGS.working_directory,
+            pidfile=pidlockfile.TimeoutPIDLockFile(FLAGS.pidfile,
+                                                   acquire_timeout=1,
+                                                   threaded=False),
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            uid=FLAGS.uid,
+            gid=FLAGS.gid
+            ):
+        main(args)

=== added file 'glance/common/utils.py'
--- glance/common/utils.py	1970-01-01 00:00:00 +0000
+++ glance/common/utils.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,204 @@
+# 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.
+
+"""
+System-level utilities and helper functions.
+"""
+
+import datetime
+import inspect
+import logging
+import os
+import random
+import subprocess
+import socket
+import sys
+
+from twisted.internet.threads import deferToThread
+
+from glance.common import exception
+from glance.common import flags
+from glance.common.exception import ProcessExecutionError
+
+
+FLAGS = flags.FLAGS
+TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+def import_class(import_str):
+    """Returns a class from a string including module and class"""
+    mod_str, _sep, class_str = import_str.rpartition('.')
+    try:
+        __import__(mod_str)
+        return getattr(sys.modules[mod_str], class_str)
+    except (ImportError, ValueError, AttributeError):
+        raise exception.NotFound('Class %s cannot be found' % class_str)
+
+def import_object(import_str):
+    """Returns an object including a module or module and class"""
+    try:
+        __import__(import_str)
+        return sys.modules[import_str]
+    except ImportError:
+        cls = import_class(import_str)
+        return cls()
+
+def fetchfile(url, target):
+    logging.debug("Fetching %s" % url)
+#    c = pycurl.Curl()
+#    fp = open(target, "wb")
+#    c.setopt(c.URL, url)
+#    c.setopt(c.WRITEDATA, fp)
+#    c.perform()
+#    c.close()
+#    fp.close()
+    execute("curl --fail %s -o %s" % (url, target))
+
+def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
+    logging.debug("Running cmd: %s", cmd)
+    env = os.environ.copy()
+    if addl_env:
+        env.update(addl_env)
+    obj = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
+    result = None
+    if process_input != None:
+        result = obj.communicate(process_input)
+    else:
+        result = obj.communicate()
+    obj.stdin.close()
+    if obj.returncode:
+        logging.debug("Result was %s" % (obj.returncode))
+        if check_exit_code and obj.returncode <> 0:
+            (stdout, stderr) = result
+            raise ProcessExecutionError(exit_code=obj.returncode,
+                                        stdout=stdout,
+                                        stderr=stderr,
+                                        cmd=cmd)
+    return result
+
+
+def abspath(s):
+    return os.path.join(os.path.dirname(__file__), s)
+
+
+# TODO(sirp): when/if utils is extracted to common library, we should remove
+# the argument's default.
+#def default_flagfile(filename='nova.conf'):
+def default_flagfile(filename='glance.conf'):
+    for arg in sys.argv:
+        if arg.find('flagfile') != -1:
+            break
+    else:
+        if not os.path.isabs(filename):
+            # turn relative filename into an absolute path
+            script_dir = os.path.dirname(inspect.stack()[-1][1])
+            filename = os.path.abspath(os.path.join(script_dir, filename))
+        if os.path.exists(filename):
+            sys.argv = sys.argv[:1] + ['--flagfile=%s' % filename] + sys.argv[1:]
+
+
+def debug(arg):
+    logging.debug('debug in callback: %s', arg)
+    return arg
+
+
+def runthis(prompt, cmd, check_exit_code = True):
+    logging.debug("Running %s" % (cmd))
+    exit_code = subprocess.call(cmd.split(" "))
+    logging.debug(prompt % (exit_code))
+    if check_exit_code and exit_code <> 0:
+        raise ProcessExecutionError(exit_code=exit_code,
+                                    stdout=None,
+                                    stderr=None,
+                                    cmd=cmd)
+
+
+def generate_uid(topic, size=8):
+    return '%s-%s' % (topic, ''.join([random.choice('01234567890abcdefghijklmnopqrstuvwxyz') for x in xrange(size)]))
+
+
+def generate_mac():
+    mac = [0x02, 0x16, 0x3e, random.randint(0x00, 0x7f),
+           random.randint(0x00, 0xff), random.randint(0x00, 0xff)
+           ]
+    return ':'.join(map(lambda x: "%02x" % x, mac))
+
+
+def last_octet(address):
+    return int(address.split(".")[-1])
+
+
+def get_my_ip():
+    """Returns the actual ip of the local machine."""
+    if getattr(FLAGS, 'fake_tests', None):
+        return '127.0.0.1'
+    try:
+        csock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        csock.connect(('www.google.com', 80))
+        (addr, port) = csock.getsockname()
+        csock.close()
+        return addr
+    except socket.gaierror as ex:
+        logging.warn("Couldn't get IP, using 127.0.0.1 %s", ex)
+        return "127.0.0.1"
+
+
+def isotime(at=None):
+    if not at:
+        at = datetime.datetime.utcnow()
+    return at.strftime(TIME_FORMAT)
+
+
+def parse_isotime(timestr):
+    return datetime.datetime.strptime(timestr, TIME_FORMAT)
+
+
+class LazyPluggable(object):
+    """A pluggable backend loaded lazily based on some value."""
+
+    def __init__(self, pivot, **backends):
+        self.__backends = backends
+        self.__pivot = pivot
+        self.__backend = None
+
+    def __get_backend(self):
+        if not self.__backend:
+            backend_name = self.__pivot.value
+            if backend_name not in self.__backends:
+                raise exception.Error('Invalid backend: %s' % backend_name)
+
+            backend = self.__backends[backend_name]
+            if type(backend) == type(tuple()):
+                name = backend[0]
+                fromlist = backend[1]
+            else:
+                name = backend
+                fromlist = backend
+
+            self.__backend = __import__(name, None, None, fromlist)
+            logging.info('backend %s', self.__backend)
+        return self.__backend
+
+    def __getattr__(self, key):
+        backend = self.__get_backend()
+        return getattr(backend, key)
+
+def deferredToThread(f):
+    def g(*args, **kwargs):
+        return deferToThread(f, *args, **kwargs)
+    return g

=== added file 'glance/common/wsgi.py'
--- glance/common/wsgi.py	1970-01-01 00:00:00 +0000
+++ glance/common/wsgi.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,298 @@
+# 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
+#    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.
+
+"""
+Utility methods for working with WSGI servers
+"""
+
+import logging
+import sys
+
+import eventlet
+import eventlet.wsgi
+eventlet.patcher.monkey_patch(all=False, socket=True)
+import routes
+import routes.middleware
+import webob.dec
+import webob.exc
+
+
+logging.getLogger("routes.middleware").addHandler(logging.StreamHandler())
+
+
+def run_server(application, port):
+    """Run a WSGI server with the given application."""
+    sock = eventlet.listen(('0.0.0.0', port))
+    eventlet.wsgi.server(sock, application)
+
+
+class Application(object):
+# TODO(gundlach): I think we should toss this class, now that it has no
+# purpose.
+    """Base WSGI application wrapper. Subclasses need to implement __call__."""
+
+    def __call__(self, environ, start_response):
+        r"""Subclasses will probably want to implement __call__ like this:
+
+        @webob.dec.wsgify
+        def __call__(self, req):
+          # Any of the following objects work as responses:
+
+          # Option 1: simple string
+          res = 'message\n'
+
+          # Option 2: a nicely formatted HTTP exception page
+          res = exc.HTTPForbidden(detail='Nice try')
+
+          # Option 3: a webob Response object (in case you need to play with
+          # headers, or you want to be treated like an iterable, or or or)
+          res = Response();
+          res.app_iter = open('somefile')
+
+          # Option 4: any wsgi app to be run next
+          res = self.application
+
+          # Option 5: you can get a Response object for a wsgi app, too, to
+          # play with headers etc
+          res = req.get_response(self.application)
+
+          # You can then just return your response...
+          return res
+          # ... or set req.response and return None.
+          req.response = res
+
+        See the end of http://pythonpaste.org/webob/modules/dec.html
+        for more info.
+        """
+        raise NotImplementedError("You must implement __call__")
+
+
+class Middleware(Application):
+    """
+    Base WSGI middleware wrapper. These classes require an application to be
+    initialized that will be called next.  By default the middleware will
+    simply call its wrapped app, or you can override __call__ to customize its
+    behavior.
+    """
+
+    def __init__(self, application): # pylint: disable-msg=W0231
+        self.application = application
+
+    @webob.dec.wsgify
+    def __call__(self, req): # pylint: disable-msg=W0221
+        """Override to implement middleware behavior."""
+        return self.application
+
+
+class Debug(Middleware):
+    """Helper class that can be inserted into any WSGI application chain
+    to get information about the request and response."""
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        print ("*" * 40) + " REQUEST ENVIRON"
+        for key, value in req.environ.items():
+            print key, "=", value
+        print
+        resp = req.get_response(self.application)
+
+        print ("*" * 40) + " RESPONSE HEADERS"
+        for (key, value) in resp.headers.iteritems():
+            print key, "=", value
+        print
+
+        resp.app_iter = self.print_generator(resp.app_iter)
+
+        return resp
+
+    @staticmethod
+    def print_generator(app_iter):
+        """
+        Iterator that prints the contents of a wrapper string iterator
+        when iterated.
+        """
+        print ("*" * 40) + " BODY"
+        for part in app_iter:
+            sys.stdout.write(part)
+            sys.stdout.flush()
+            yield part
+        print
+
+
+class Router(object):
+    """
+    WSGI middleware that maps incoming requests to WSGI apps.
+    """
+
+    def __init__(self, mapper):
+        """
+        Create a router for the given routes.Mapper.
+
+        Each route in `mapper` must specify a 'controller', which is a
+        WSGI app to call.  You'll probably want to specify an 'action' as
+        well and have your controller be a wsgi.Controller, who will route
+        the request to the action method.
+
+        Examples:
+          mapper = routes.Mapper()
+          sc = ServerController()
+
+          # Explicit mapping of one route to a controller+action
+          mapper.connect(None, "/svrlist", controller=sc, action="list")
+
+          # Actions are all implicitly defined
+          mapper.resource("server", "servers", controller=sc)
+
+          # Pointing to an arbitrary WSGI app.  You can specify the
+          # {path_info:.*} parameter so the target app can be handed just that
+          # section of the URL.
+          mapper.connect(None, "/v1.0/{path_info:.*}", controller=BlogApp())
+        """
+        self.map = mapper
+        self._router = routes.middleware.RoutesMiddleware(self._dispatch,
+                                                          self.map)
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        """
+        Route the incoming request to a controller based on self.map.
+        If no match, return a 404.
+        """
+        return self._router
+
+    @staticmethod
+    @webob.dec.wsgify
+    def _dispatch(req):
+        """
+        Called by self._router after matching the incoming request to a route
+        and putting the information into req.environ.  Either returns 404
+        or the routed WSGI app's response.
+        """
+        match = req.environ['wsgiorg.routing_args'][1]
+        if not match:
+            return webob.exc.HTTPNotFound()
+        app = match['controller']
+        return app
+
+
+class Controller(object):
+    """
+    WSGI app that reads routing information supplied by RoutesMiddleware
+    and calls the requested action method upon itself.  All action methods
+    must, in addition to their normal parameters, accept a 'req' argument
+    which is the incoming webob.Request.  They raise a webob.exc exception,
+    or return a dict which will be serialized by requested content type.
+    """
+
+    @webob.dec.wsgify
+    def __call__(self, req):
+        """
+        Call the method specified in req.environ by RoutesMiddleware.
+        """
+        arg_dict = req.environ['wsgiorg.routing_args'][1]
+        action = arg_dict['action']
+        method = getattr(self, action)
+        del arg_dict['controller']
+        del arg_dict['action']
+        arg_dict['req'] = req
+        result = method(**arg_dict)
+        if type(result) is dict:
+            return self._serialize(result, req) 
+        else:
+            return result
+
+    def _serialize(self, data, request):
+        """
+        Serialize the given dict to the response type requested in request.
+        Uses self._serialization_metadata if it exists, which is a dict mapping
+        MIME types to information needed to serialize to that type.
+        """
+        # FIXME(sirp): type(self) should just be `self`
+        _metadata = getattr(type(self), "_serialization_metadata", {})
+        serializer = Serializer(request.environ, _metadata)
+        return serializer.to_content_type(data)
+
+
+class Serializer(object):
+    """
+    Serializes a dictionary to a Content Type specified by a WSGI environment.
+    """
+
+    def __init__(self, environ, metadata=None):
+        """
+        Create a serializer based on the given WSGI environment.
+        'metadata' is an optional dict mapping MIME types to information
+        needed to serialize a dictionary to that type.
+        """
+        self.environ = environ
+        self.metadata = metadata or {}
+        self._methods = {
+            'application/json': self._to_json,
+            'application/xml': self._to_xml}
+
+    def to_content_type(self, data):
+        """
+        Serialize a dictionary into a string.  The format of the string
+        will be decided based on the Content Type requested in self.environ:
+        by Accept: header, or by URL suffix.
+        """
+        # FIXME(sirp): for now, supporting json only
+        #mimetype = 'application/xml'
+        mimetype = 'application/json'
+        # TODO(gundlach): determine mimetype from request
+        return self._methods.get(mimetype, repr)(data)
+
+    def _to_json(self, data):
+        import json
+        return json.dumps(data)
+
+    def _to_xml(self, data):
+        metadata = self.metadata.get('application/xml', {})
+        # We expect data to contain a single key which is the XML root.
+        root_key = data.keys()[0]
+        from xml.dom import minidom
+        doc = minidom.Document()
+        node = self._to_xml_node(doc, metadata, root_key, data[root_key])
+        return node.toprettyxml(indent='    ')
+
+    def _to_xml_node(self, doc, metadata, nodename, data):
+        """Recursive method to convert data members to XML nodes."""
+        result = doc.createElement(nodename)
+        if type(data) is list:
+            singular = metadata.get('plurals', {}).get(nodename, None)
+            if singular is None:
+                if nodename.endswith('s'):
+                    singular = nodename[:-1]
+                else:
+                    singular = 'item'
+            for item in data:
+                node = self._to_xml_node(doc, metadata, singular, item)
+                result.appendChild(node)
+        elif type(data) is dict:
+            attrs = metadata.get('attributes', {}).get(nodename, {})
+            for k, v in data.items():
+                if k in attrs:
+                    result.setAttribute(k, str(v))
+                else:
+                    node = self._to_xml_node(doc, metadata, k, v)
+                    result.appendChild(node)
+        else: # atom
+            node = doc.createTextNode(str(data))
+            result.appendChild(node)
+        return result

=== modified file 'glance/parallax/__init__.py'
--- glance/parallax/__init__.py	2010-08-24 04:32:57 +0000
+++ glance/parallax/__init__.py	2010-09-29 20:56:47 +0000
@@ -1,16 +1,21 @@
-class ImageRegistry(object):
-    """
-    {
-        "uuid": uuid,
-        "slug": slug,
-        "name": name,
-        "objects": [
-            { "uri": obj1_uri },
-            { "uri": obj2_uri }
-        ]
-    }
-    """
-    def __init__(self):
-        pass
-
-
+# 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 
+"""

=== added directory 'glance/parallax/api'
=== added file 'glance/parallax/api/__init__.py'
--- glance/parallax/api/__init__.py	1970-01-01 00:00:00 +0000
+++ glance/parallax/api/__init__.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,49 @@
+# 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)
+

=== added file 'glance/parallax/api/images.py'
--- glance/parallax/api/images.py	1970-01-01 00:00:00 +0000
+++ glance/parallax/api/images.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,82 @@
+# 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 'tests/test_data.py'
--- tests/test_data.py	1970-01-01 00:00:00 +0000
+++ tests/test_data.py	2010-09-29 20:56:47 +0000
@@ -0,0 +1,49 @@
+# 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.db import api
+
+
+def make_fake_image():
+    """Create a fake image record """
+    image = api.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))
+
+    api.image_metadatum_create(
+        None,
+        dict(image_id=image.id,
+             key="testkey",
+             value="testvalue"))
+
+
+if __name__ == "__main__":
+    make_fake_image()