diff --git a/glance/api/cached_images.py b/glance/api/cached_images.py
index 7efe1139c3..214a02ba18 100644
--- a/glance/api/cached_images.py
+++ b/glance/api/cached_images.py
@@ -37,9 +37,9 @@ class Controller(controller.BaseController):
     A controller for managing cached images.
     """
 
-    def __init__(self, options):
-        self.options = options
-        self.cache = image_cache.ImageCache(self.options)
+    def __init__(self, conf):
+        self.conf = conf
+        self.cache = image_cache.ImageCache(self.conf)
 
     def get_cached_images(self, req):
         """
@@ -110,8 +110,8 @@ class CachedImageSerializer(wsgi.JSONResponseSerializer):
     pass
 
 
-def create_resource(options):
+def create_resource(conf):
     """Cached Images resource factory method"""
     deserializer = CachedImageDeserializer()
     serializer = CachedImageSerializer()
-    return wsgi.Resource(Controller(options), deserializer, serializer)
+    return wsgi.Resource(Controller(conf), deserializer, serializer)
diff --git a/glance/api/middleware/cache.py b/glance/api/middleware/cache.py
index ce79f0bbc8..f236abc23b 100644
--- a/glance/api/middleware/cache.py
+++ b/glance/api/middleware/cache.py
@@ -43,9 +43,9 @@ get_images_re = re.compile(r'^(/v\d+)*/images/(.+)$')
 
 class CacheFilter(wsgi.Middleware):
 
-    def __init__(self, app, options):
-        self.options = options
-        self.cache = image_cache.ImageCache(options)
+    def __init__(self, app, conf):
+        self.conf = conf
+        self.cache = image_cache.ImageCache(conf)
         self.serializer = images.ImageSerializer()
         logger.info(_("Initialized image cache middleware"))
         super(CacheFilter, self).__init__(app)
diff --git a/glance/api/middleware/cache_manage.py b/glance/api/middleware/cache_manage.py
index 285d180ffd..07ae2cb94c 100644
--- a/glance/api/middleware/cache_manage.py
+++ b/glance/api/middleware/cache_manage.py
@@ -28,10 +28,10 @@ logger = logging.getLogger(__name__)
 
 
 class CacheManageFilter(wsgi.Middleware):
-    def __init__(self, app, options):
+    def __init__(self, app, conf):
 
         map = app.map
-        resource = cached_images.create_resource(options)
+        resource = cached_images.create_resource(conf)
 
         map.connect("/cached_images",
                     controller=resource,
diff --git a/glance/api/middleware/version_negotiation.py b/glance/api/middleware/version_negotiation.py
index 9605feb63b..73d597ed59 100644
--- a/glance/api/middleware/version_negotiation.py
+++ b/glance/api/middleware/version_negotiation.py
@@ -35,10 +35,10 @@ logger = logging.getLogger('glance.api.middleware.version_negotiation')
 
 class VersionNegotiationFilter(wsgi.Middleware):
 
-    def __init__(self, app, options):
-        self.versions_app = versions.Controller(options)
+    def __init__(self, app, conf):
+        self.versions_app = versions.Controller(conf)
         self.version_uri_regex = re.compile(r"^v(\d+)\.?(\d+)?")
-        self.options = options
+        self.conf = conf
         super(VersionNegotiationFilter, self).__init__(app)
 
     def process_request(self, req):
diff --git a/glance/api/v1/images.py b/glance/api/v1/images.py
index 42ab7d9eb4..71f7a999fe 100644
--- a/glance/api/v1/images.py
+++ b/glance/api/v1/images.py
@@ -76,11 +76,11 @@ class Controller(controller.BaseController):
         DELETE /images/<ID> -- Delete the image with id <ID>
     """
 
-    def __init__(self, options):
-        self.options = options
-        glance.store.create_stores(options)
-        self.notifier = notifier.Notifier(options)
-        registry.configure_registry_client(options)
+    def __init__(self, conf):
+        self.conf = conf
+        glance.store.create_stores(conf)
+        self.notifier = notifier.Notifier(conf)
+        registry.configure_registry_client(conf)
 
     def index(self, req):
         """
@@ -290,7 +290,7 @@ class Controller(controller.BaseController):
             raise HTTPBadRequest(explanation=msg)
 
         store_name = req.headers.get('x-image-meta-store',
-                                     self.options['default_store'])
+                                     self.conf['default_store'])
 
         store = self.get_store_or_400(req, store_name)
 
@@ -557,7 +557,7 @@ class Controller(controller.BaseController):
         # See https://bugs.launchpad.net/glance/+bug/747799
         try:
             if image['location']:
-                schedule_delete_from_backend(image['location'], self.options,
+                schedule_delete_from_backend(image['location'], self.conf,
                                              req.context, id)
             registry.delete_image_metadata(req.context, id)
         except exception.NotFound, e:
@@ -706,8 +706,8 @@ class ImageSerializer(wsgi.JSONResponseSerializer):
         return response
 
 
-def create_resource(options):
+def create_resource(conf):
     """Images resource factory method"""
     deserializer = ImageDeserializer()
     serializer = ImageSerializer()
-    return wsgi.Resource(Controller(options), deserializer, serializer)
+    return wsgi.Resource(Controller(conf), deserializer, serializer)
diff --git a/glance/api/v1/members.py b/glance/api/v1/members.py
index 439f53e97c..ae9dd5f6aa 100644
--- a/glance/api/v1/members.py
+++ b/glance/api/v1/members.py
@@ -14,8 +14,8 @@ logger = logging.getLogger('glance.api.v1.members')
 
 class Controller(object):
 
-    def __init__(self, options):
-        self.options = options
+    def __init__(self, conf):
+        self.conf = conf
 
     def index(self, req, image_id):
         """
@@ -158,8 +158,8 @@ class Controller(object):
         return dict(shared_images=members)
 
 
-def create_resource(options):
+def create_resource(conf):
     """Image members resource factory method"""
     deserializer = wsgi.JSONRequestDeserializer()
     serializer = wsgi.JSONResponseSerializer()
-    return wsgi.Resource(Controller(options), deserializer, serializer)
+    return wsgi.Resource(Controller(conf), deserializer, serializer)
diff --git a/glance/api/v1/router.py b/glance/api/v1/router.py
index 4a9613eb94..6e0ac3dc1e 100644
--- a/glance/api/v1/router.py
+++ b/glance/api/v1/router.py
@@ -30,11 +30,11 @@ class API(wsgi.Router):
 
     """WSGI router for Glance v1 API requests."""
 
-    def __init__(self, options):
-        self.options = options
+    def __init__(self, conf):
+        self.conf = conf
         mapper = routes.Mapper()
 
-        images_resource = images.create_resource(options)
+        images_resource = images.create_resource(conf)
 
         mapper.resource("image", "images", controller=images_resource,
                         collection={'detail': 'GET'})
@@ -42,7 +42,7 @@ class API(wsgi.Router):
         mapper.connect("/images/{id}", controller=images_resource,
                        action="meta", conditions=dict(method=["HEAD"]))
 
-        members_resource = members.create_resource(options)
+        members_resource = members.create_resource(conf)
 
         mapper.resource("member", "members", controller=members_resource,
                         parent_resource=dict(member_name='image',
diff --git a/glance/api/versions.py b/glance/api/versions.py
index 5f29ed1dcd..924e41525c 100644
--- a/glance/api/versions.py
+++ b/glance/api/versions.py
@@ -31,8 +31,8 @@ class Controller(object):
     A controller that produces information on the Glance API versions.
     """
 
-    def __init__(self, options):
-        self.options = options
+    def __init__(self, conf):
+        self.conf = conf
 
     @webob.dec.wsgify
     def __call__(self, req):
@@ -63,5 +63,5 @@ class Controller(object):
         return response
 
     def get_href(self):
-        return "http://%s:%s/v1/" % (self.options['bind_host'],
-                                      self.options['bind_port'])
+        return "http://%s:%s/v1/" % (self.conf['bind_host'],
+                                     self.conf['bind_port'])
diff --git a/glance/common/context.py b/glance/common/context.py
index f6c4d5e5e9..e756540bdd 100644
--- a/glance/common/context.py
+++ b/glance/common/context.py
@@ -53,8 +53,8 @@ class RequestContext(object):
 
 
 class ContextMiddleware(wsgi.Middleware):
-    def __init__(self, app, options):
-        self.options = options
+    def __init__(self, app, conf):
+        self.conf = conf
         super(ContextMiddleware, self).__init__(app)
 
     def make_context(self, *args, **kwargs):
@@ -64,11 +64,11 @@ class ContextMiddleware(wsgi.Middleware):
 
         # Determine the context class to use
         ctxcls = RequestContext
-        if 'context_class' in self.options:
-            ctxcls = utils.import_class(self.options['context_class'])
+        if 'context_class' in self.conf:
+            ctxcls = utils.import_class(self.conf['context_class'])
 
         # Determine whether to use tenant or owner
-        owner_is_tenant = config.get_option(self.options, 'owner_is_tenant',
+        owner_is_tenant = config.get_option(self.conf, 'owner_is_tenant',
                                             type='bool', default=True)
         kwargs.setdefault('owner_is_tenant', owner_is_tenant)
 
diff --git a/glance/common/notifier.py b/glance/common/notifier.py
index 2cc6082319..f2561693f6 100644
--- a/glance/common/notifier.py
+++ b/glance/common/notifier.py
@@ -29,7 +29,7 @@ from glance.common import exception
 class NoopStrategy(object):
     """A notifier that does nothing when called."""
 
-    def __init__(self, options):
+    def __init__(self, conf):
         pass
 
     def warn(self, msg):
@@ -45,7 +45,7 @@ class NoopStrategy(object):
 class LoggingStrategy(object):
     """A notifier that calls logging when called."""
 
-    def __init__(self, options):
+    def __init__(self, conf):
         self.logger = logging.getLogger('glance.notifier.logging_notifier')
 
     def warn(self, msg):
@@ -61,9 +61,9 @@ class LoggingStrategy(object):
 class RabbitStrategy(object):
     """A notifier that puts a message on a queue when called."""
 
-    def __init__(self, options):
+    def __init__(self, conf):
         """Initialize the rabbit notification strategy."""
-        self._options = options
+        self._conf = conf
         host = self._get_option('rabbit_host', 'str', 'localhost')
         port = self._get_option('rabbit_port', 'int', 5672)
         use_ssl = self._get_option('rabbit_use_ssl', 'bool', False)
@@ -84,7 +84,7 @@ class RabbitStrategy(object):
 
     def _get_option(self, name, datatype, default):
         """Retrieve a configuration option."""
-        return config.get_option(self._options,
+        return config.get_option(self._conf,
                                  name,
                                  type=datatype,
                                  default=default)
@@ -115,11 +115,11 @@ class Notifier(object):
         "default": NoopStrategy,
     }
 
-    def __init__(self, options, strategy=None):
-        strategy = config.get_option(options, "notifier_strategy",
+    def __init__(self, conf, strategy=None):
+        strategy = config.get_option(conf, "notifier_strategy",
                                      type="str", default="default")
         try:
-            self.strategy = self.STRATEGIES[strategy](options)
+            self.strategy = self.STRATEGIES[strategy](conf)
         except KeyError:
             raise exception.InvalidNotifierStrategy(strategy=strategy)
 
diff --git a/glance/image_cache/__init__.py b/glance/image_cache/__init__.py
index 3baa184d64..543a2533fe 100644
--- a/glance/image_cache/__init__.py
+++ b/glance/image_cache/__init__.py
@@ -34,15 +34,15 @@ class ImageCache(object):
 
     """Provides an LRU cache for image data."""
 
-    def __init__(self, options):
-        self.options = options
+    def __init__(self, conf):
+        self.conf = conf
         self.init_driver()
 
     def init_driver(self):
         """
         Create the driver for the cache
         """
-        driver_name = self.options.get('image_cache_driver', 'sqlite')
+        driver_name = self.conf.get('image_cache_driver', 'sqlite')
         driver_module = (__name__ + '.drivers.' + driver_name + '.Driver')
         try:
             self.driver_class = utils.import_class(driver_module)
@@ -64,7 +64,7 @@ class ImageCache(object):
         fall back to using the SQLite driver which has no odd dependencies
         """
         try:
-            self.driver = self.driver_class(self.options)
+            self.driver = self.driver_class(self.conf)
             self.driver.configure()
         except exception.BadDriverConfiguration, config_err:
             driver_module = self.driver_class.__module__
@@ -74,7 +74,7 @@ class ImageCache(object):
             logger.info(_("Defaulting to SQLite driver."))
             default_module = __name__ + '.drivers.sqlite.Driver'
             self.driver_class = utils.import_class(default_module)
-            self.driver = self.driver_class(self.options)
+            self.driver = self.driver_class(self.conf)
             self.driver.configure()
 
     def is_cached(self, image_id):
@@ -150,8 +150,8 @@ class ImageCache(object):
         size. Returns a tuple containing the total number of cached
         files removed and the total size of all pruned image files.
         """
-        max_size = int(self.options.get('image_cache_max_size',
-                                        DEFAULT_MAX_CACHE_SIZE))
+        max_size = int(self.conf.get('image_cache_max_size',
+                                     DEFAULT_MAX_CACHE_SIZE))
         current_size = self.driver.get_cache_size()
         if max_size > current_size:
             logger.debug(_("Image cache has free space, skipping prune..."))
diff --git a/glance/image_cache/cleaner.py b/glance/image_cache/cleaner.py
index adced3360c..f93c4d1b61 100644
--- a/glance/image_cache/cleaner.py
+++ b/glance/image_cache/cleaner.py
@@ -27,9 +27,9 @@ logger = logging.getLogger(__name__)
 
 
 class Cleaner(object):
-    def __init__(self, options):
-        self.options = options
-        self.cache = ImageCache(options)
+    def __init__(self, conf):
+        self.conf = conf
+        self.cache = ImageCache(conf)
 
     def run(self):
         self.cache.clean()
diff --git a/glance/image_cache/drivers/base.py b/glance/image_cache/drivers/base.py
index ce1d2c7cbc..4c28a44009 100644
--- a/glance/image_cache/drivers/base.py
+++ b/glance/image_cache/drivers/base.py
@@ -33,15 +33,15 @@ logger = logging.getLogger(__name__)
 
 class Driver(object):
 
-    def __init__(self, options):
+    def __init__(self, conf):
         """
         Initialize the attribute driver with a set of options.
 
-        :param options: Dictionary of configuration file options
+        :param conf: Dictionary of configuration options
         :raises `exception.BadDriverConfiguration` if configuration of the
                 driver fails for any reason.
         """
-        self.options = options or {}
+        self.conf = conf or {}
 
     def configure(self):
         """
@@ -62,7 +62,7 @@ class Driver(object):
 
         try:
             key = 'image_cache_dir'
-            self.base_dir = self.options[key]
+            self.base_dir = self.conf[key]
         except KeyError:
             msg = _('Failed to read %s from config') % key
             logger.error(msg)
diff --git a/glance/image_cache/drivers/sqlite.py b/glance/image_cache/drivers/sqlite.py
index f4962829ef..9d4c5b5e00 100644
--- a/glance/image_cache/drivers/sqlite.py
+++ b/glance/image_cache/drivers/sqlite.py
@@ -95,7 +95,7 @@ class Driver(base.Driver):
         self.initialize_db()
 
     def initialize_db(self):
-        db = self.options.get('image_cache_sqlite_db', DEFAULT_SQLITE_DB)
+        db = self.conf.get('image_cache_sqlite_db', DEFAULT_SQLITE_DB)
         self.db_path = os.path.join(self.base_dir, db)
         try:
             conn = sqlite3.connect(self.db_path, check_same_thread=False,
@@ -252,8 +252,8 @@ class Driver(base.Driver):
         """
         self.delete_invalid_files()
 
-        incomplete_stall_time = int(self.options.get('image_cache_stall_time',
-                                                     DEFAULT_STALL_TIME))
+        incomplete_stall_time = int(self.conf.get('image_cache_stall_time',
+                                                  DEFAULT_STALL_TIME))
         now = time.time()
         older_than = now - incomplete_stall_time
         self.delete_stalled_files(older_than)
diff --git a/glance/image_cache/drivers/xattr.py b/glance/image_cache/drivers/xattr.py
index 8bc5e51cfc..b1e30bd508 100644
--- a/glance/image_cache/drivers/xattr.py
+++ b/glance/image_cache/drivers/xattr.py
@@ -424,8 +424,8 @@ class Driver(base.Driver):
         """
         self.reap_invalid()
 
-        incomplete_stall_time = int(self.options.get('image_cache_stall_time',
-                                                     DEFAULT_STALL_TIME))
+        incomplete_stall_time = int(self.conf.get('image_cache_stall_time',
+                                                  DEFAULT_STALL_TIME))
         self.reap_stalled(incomplete_stall_time)
 
 
diff --git a/glance/image_cache/prefetcher.py b/glance/image_cache/prefetcher.py
index faacba559e..ffdf6942c0 100644
--- a/glance/image_cache/prefetcher.py
+++ b/glance/image_cache/prefetcher.py
@@ -42,14 +42,14 @@ logger = logging.getLogger(__name__)
 
 class Prefetcher(object):
 
-    def __init__(self, options):
-        self.options = options
-        glance.store.create_stores(options)
-        self.cache = ImageCache(options)
-        registry.configure_registry_client(options)
+    def __init__(self, conf):
+        self.conf = conf
+        glance.store.create_stores(conf)
+        self.cache = ImageCache(conf)
+        registry.configure_registry_client(conf)
 
     def fetch_image_into_cache(self, image_id):
-        auth_tok = self.options.get('admin_token')
+        auth_tok = self.conf.get('admin_token')
         ctx = context.RequestContext(is_admin=True, show_deleted=True,
                                      auth_tok=auth_tok)
         try:
diff --git a/glance/image_cache/pruner.py b/glance/image_cache/pruner.py
index 01583f62e8..14769c8dd2 100644
--- a/glance/image_cache/pruner.py
+++ b/glance/image_cache/pruner.py
@@ -27,9 +27,9 @@ logger = logging.getLogger(__name__)
 
 
 class Pruner(object):
-    def __init__(self, options):
-        self.options = options
-        self.cache = ImageCache(options)
+    def __init__(self, conf):
+        self.conf = conf
+        self.cache = ImageCache(conf)
 
     def run(self):
         self.cache.prune()
diff --git a/glance/image_cache/queue_image.py b/glance/image_cache/queue_image.py
index d60c2b7b9a..6718217198 100644
--- a/glance/image_cache/queue_image.py
+++ b/glance/image_cache/queue_image.py
@@ -35,13 +35,13 @@ logger = logging.getLogger(__name__)
 
 class Queuer(object):
 
-    def __init__(self, options):
-        self.options = options
-        self.cache = ImageCache(options)
-        registry.configure_registry_client(options)
+    def __init__(self, conf):
+        self.conf = conf
+        self.cache = ImageCache(conf)
+        registry.configure_registry_client(conf)
 
     def queue_image(self, image_id):
-        auth_tok = self.options.get('admin_token')
+        auth_tok = self.conf.get('admin_token')
         ctx = context.RequestContext(is_admin=True, show_deleted=True,
                                      auth_tok=auth_tok)
         try:
diff --git a/glance/registry/__init__.py b/glance/registry/__init__.py
index 1db37d3383..04607b33a4 100644
--- a/glance/registry/__init__.py
+++ b/glance/registry/__init__.py
@@ -34,16 +34,16 @@ _CLIENT_KWARGS = {}
 _METADATA_ENCRYPTION_KEY = None
 
 
-def configure_registry_client(options):
+def configure_registry_client(conf):
     """
     Sets up a registry client for use in registry lookups
 
-    :param options: Configuration options coming from controller
+    :param conf: Configuration options coming from controller
     """
     global _CLIENT_KWARGS, _CLIENT_HOST, _CLIENT_PORT, _METADATA_ENCRYPTION_KEY
     try:
-        host = options['registry_host']
-        port = int(options['registry_port'])
+        host = conf['registry_host']
+        port = int(conf['registry_port'])
     except (TypeError, ValueError):
         msg = _("Configuration option was not valid")
         logger.error(msg)
@@ -53,12 +53,12 @@ def configure_registry_client(options):
         logger.error(msg)
         raise exception.BadRegistryConnectionConfiguration(msg)
 
-    use_ssl = config.get_option(options, 'registry_client_protocol',
+    use_ssl = config.get_option(conf, 'registry_client_protocol',
                                 default='http').lower() == 'https'
-    key_file = options.get('registry_client_key_file')
-    cert_file = options.get('registry_client_cert_file')
-    ca_file = options.get('registry_client_ca_file')
-    _METADATA_ENCRYPTION_KEY = options.get('metadata_encryption_key')
+    key_file = conf.get('registry_client_key_file')
+    cert_file = conf.get('registry_client_cert_file')
+    ca_file = conf.get('registry_client_ca_file')
+    _METADATA_ENCRYPTION_KEY = conf.get('metadata_encryption_key')
     _CLIENT_HOST = host
     _CLIENT_PORT = port
     _CLIENT_KWARGS = {'use_ssl': use_ssl,
diff --git a/glance/registry/api/v1/__init__.py b/glance/registry/api/v1/__init__.py
index f98a4e86fc..a975429733 100644
--- a/glance/registry/api/v1/__init__.py
+++ b/glance/registry/api/v1/__init__.py
@@ -25,15 +25,15 @@ from glance.common import wsgi
 class API(wsgi.Router):
     """WSGI entry point for all Registry requests."""
 
-    def __init__(self, options):
+    def __init__(self, conf):
         mapper = routes.Mapper()
 
-        images_resource = images.create_resource(options)
+        images_resource = images.create_resource(conf)
         mapper.resource("image", "images", controller=images_resource,
                         collection={'detail': 'GET'})
         mapper.connect("/", controller=images_resource, action="index")
 
-        members_resource = members.create_resource(options)
+        members_resource = members.create_resource(conf)
         mapper.resource("member", "members", controller=members_resource,
                         parent_resource=dict(member_name='image',
                         collection_name='images'))
diff --git a/glance/registry/api/v1/images.py b/glance/registry/api/v1/images.py
index fdfaed222e..fb0a247b7e 100644
--- a/glance/registry/api/v1/images.py
+++ b/glance/registry/api/v1/images.py
@@ -49,9 +49,9 @@ SUPPORTED_PARAMS = ('limit', 'marker', 'sort_key', 'sort_dir')
 
 class Controller(object):
 
-    def __init__(self, options):
-        self.options = options
-        db_api.configure_db(options)
+    def __init__(self, conf):
+        self.conf = conf
+        db_api.configure_db(conf)
 
     def _get_images(self, context, **params):
         """
@@ -181,7 +181,7 @@ class Controller(object):
     def _get_limit(self, req):
         """Parse a limit query param into something usable."""
         try:
-            default = self.options['limit_param_default']
+            default = self.conf['limit_param_default']
         except KeyError:
             # if no value is configured, provide a sane default
             default = 25
@@ -198,7 +198,7 @@ class Controller(object):
             raise exc.HTTPBadRequest(_("limit param must be positive"))
 
         try:
-            api_limit_max = int(self.options['api_limit_max'])
+            api_limit_max = int(self.conf['api_limit_max'])
         except (KeyError, ValueError):
             api_limit_max = 1000
             msg = _("Failed to read api_limit_max from config. "
@@ -417,8 +417,8 @@ def make_image_dict(image):
     return image_dict
 
 
-def create_resource(options):
+def create_resource(conf):
     """Images resource factory method."""
     deserializer = wsgi.JSONRequestDeserializer()
     serializer = wsgi.JSONResponseSerializer()
-    return wsgi.Resource(Controller(options), deserializer, serializer)
+    return wsgi.Resource(Controller(conf), deserializer, serializer)
diff --git a/glance/registry/api/v1/members.py b/glance/registry/api/v1/members.py
index 89b434c0d4..d518a375f1 100644
--- a/glance/registry/api/v1/members.py
+++ b/glance/registry/api/v1/members.py
@@ -29,9 +29,9 @@ logger = logging.getLogger('glance.registry.api.v1.members')
 
 class Controller(object):
 
-    def __init__(self, options):
-        self.options = options
-        db_api.configure_db(options)
+    def __init__(self, conf):
+        self.conf = conf
+        db_api.configure_db(conf)
 
     def index(self, req, image_id):
         """
@@ -296,8 +296,8 @@ def make_member_list(members, **attr_map):
             if not memb.deleted]
 
 
-def create_resource(options):
+def create_resource(conf):
     """Image members resource factory method."""
     deserializer = wsgi.JSONRequestDeserializer()
     serializer = wsgi.JSONResponseSerializer()
-    return wsgi.Resource(Controller(options), deserializer, serializer)
+    return wsgi.Resource(Controller(conf), deserializer, serializer)
diff --git a/glance/registry/db/__init__.py b/glance/registry/db/__init__.py
index f6bece15cd..7d20696617 100644
--- a/glance/registry/db/__init__.py
+++ b/glance/registry/db/__init__.py
@@ -20,7 +20,7 @@
 import optparse
 
 
-def add_options(parser):
+def add_conf(parser):
     """
     Adds any configuration options that the db layer might have.
 
diff --git a/glance/registry/db/api.py b/glance/registry/db/api.py
index 403107257f..2cce4cbcf3 100644
--- a/glance/registry/db/api.py
+++ b/glance/registry/db/api.py
@@ -58,22 +58,22 @@ STATUSES = ['active', 'saving', 'queued', 'killed', 'pending_delete',
             'deleted']
 
 
-def configure_db(options):
+def configure_db(conf):
     """
     Establish the database, create an engine if needed, and
     register the models.
 
-    :param options: Mapping of configuration options
+    :param conf: Mapping of configuration options
     """
     global _ENGINE, sa_logger, logger
     if not _ENGINE:
         debug = config.get_option(
-            options, 'debug', type='bool', default=False)
+            conf, 'debug', type='bool', default=False)
         verbose = config.get_option(
-            options, 'verbose', type='bool', default=False)
+            conf, 'verbose', type='bool', default=False)
         timeout = config.get_option(
-            options, 'sql_idle_timeout', type='int', default=3600)
-        sql_connection = config.get_option(options, 'sql_connection')
+            conf, 'sql_idle_timeout', type='int', default=3600)
+        sql_connection = config.get_option(conf, 'sql_connection')
         try:
             _ENGINE = create_engine(sql_connection, pool_recycle=timeout)
         except Exception, err:
diff --git a/glance/registry/db/migration.py b/glance/registry/db/migration.py
index 253107b0b1..e1ec9e6939 100644
--- a/glance/registry/db/migration.py
+++ b/glance/registry/db/migration.py
@@ -32,15 +32,15 @@ from glance.common import exception
 logger = logging.getLogger('glance.registry.db.migration')
 
 
-def db_version(options):
+def db_version(conf):
     """
     Return the database's current migration number
 
-    :param options: options dict
+    :param conf: conf dict
     :retval version number
     """
     repo_path = get_migrate_repo_path()
-    sql_connection = options['sql_connection']
+    sql_connection = conf['sql_connection']
     try:
         return versioning_api.db_version(sql_connection, repo_path)
     except versioning_exceptions.DatabaseNotControlledError, e:
@@ -49,78 +49,78 @@ def db_version(options):
         raise exception.DatabaseMigrationError(msg)
 
 
-def upgrade(options, version=None):
+def upgrade(conf, version=None):
     """
     Upgrade the database's current migration level
 
-    :param options: options dict
+    :param conf: conf dict
     :param version: version to upgrade (defaults to latest)
     :retval version number
     """
-    db_version(options)  # Ensure db is under migration control
+    db_version(conf)  # Ensure db is under migration control
     repo_path = get_migrate_repo_path()
-    sql_connection = options['sql_connection']
+    sql_connection = conf['sql_connection']
     version_str = version or 'latest'
     logger.info(_("Upgrading %(sql_connection)s to version %(version_str)s") %
                 locals())
     return versioning_api.upgrade(sql_connection, repo_path, version)
 
 
-def downgrade(options, version):
+def downgrade(conf, version):
     """
     Downgrade the database's current migration level
 
-    :param options: options dict
+    :param conf: conf dict
     :param version: version to downgrade to
     :retval version number
     """
-    db_version(options)  # Ensure db is under migration control
+    db_version(conf)  # Ensure db is under migration control
     repo_path = get_migrate_repo_path()
-    sql_connection = options['sql_connection']
+    sql_connection = conf['sql_connection']
     logger.info(_("Downgrading %(sql_connection)s to version %(version)s") %
                 locals())
     return versioning_api.downgrade(sql_connection, repo_path, version)
 
 
-def version_control(options):
+def version_control(conf):
     """
     Place a database under migration control
 
-    :param options: options dict
+    :param conf: conf dict
     """
-    sql_connection = options['sql_connection']
+    sql_connection = conf['sql_connection']
     try:
-        _version_control(options)
+        _version_control(conf)
     except versioning_exceptions.DatabaseAlreadyControlledError, e:
         msg = (_("database '%(sql_connection)s' is already under migration "
                "control") % locals())
         raise exception.DatabaseMigrationError(msg)
 
 
-def _version_control(options):
+def _version_control(conf):
     """
     Place a database under migration control
 
-    :param options: options dict
+    :param conf: conf dict
     """
     repo_path = get_migrate_repo_path()
-    sql_connection = options['sql_connection']
+    sql_connection = conf['sql_connection']
     return versioning_api.version_control(sql_connection, repo_path)
 
 
-def db_sync(options, version=None):
+def db_sync(conf, version=None):
     """
     Place a database under migration control and perform an upgrade
 
-    :param options: options dict
+    :param conf: conf dict
     :retval version number
     """
     try:
-        _version_control(options)
+        _version_control(conf)
     except versioning_exceptions.DatabaseAlreadyControlledError, e:
         pass
 
-    upgrade(options, version=version)
+    upgrade(conf, version=version)
 
 
 def get_migrate_repo_path():
diff --git a/glance/store/__init__.py b/glance/store/__init__.py
index f372ca9bd6..99f6918cc8 100644
--- a/glance/store/__init__.py
+++ b/glance/store/__init__.py
@@ -87,7 +87,7 @@ def register_store(store_module, schemes):
     location.register_scheme_map(scheme_map)
 
 
-def create_stores(options):
+def create_stores(conf):
     """
     Construct the store objects with supplied configuration options
     """
@@ -98,7 +98,7 @@ def create_stores(options):
             raise BackendException('Unable to create store. Could not find '
                                    'a class named Store in module %s.'
                                    % store_module)
-        STORES[store_module] = store_class(options)
+        STORES[store_module] = store_class(conf)
 
 
 def get_store_from_scheme(scheme):
@@ -154,11 +154,11 @@ def get_store_from_location(uri):
     return loc.store_name
 
 
-def schedule_delete_from_backend(uri, options, context, image_id, **kwargs):
+def schedule_delete_from_backend(uri, conf, context, image_id, **kwargs):
     """
     Given a uri and a time, schedule the deletion of an image.
     """
-    use_delay = config.get_option(options, 'delayed_delete', type='bool',
+    use_delay = config.get_option(conf, 'delayed_delete', type='bool',
                                   default=False)
     if not use_delay:
         registry.update_image_metadata(context, image_id,
@@ -169,8 +169,8 @@ def schedule_delete_from_backend(uri, options, context, image_id, **kwargs):
             msg = _("Failed to delete image from store (%(uri)s).") % locals()
             logger.error(msg)
 
-    datadir = config.get_option(options, 'scrubber_datadir')
-    scrub_time = config.get_option(options, 'scrub_time', type='int',
+    datadir = config.get_option(conf, 'scrubber_datadir')
+    scrub_time = config.get_option(conf, 'scrub_time', type='int',
                                    default=0)
     delete_time = time.time() + scrub_time
     file_path = os.path.join(datadir, str(image_id))
diff --git a/glance/store/base.py b/glance/store/base.py
index 8a48b603a4..64b1c9896c 100644
--- a/glance/store/base.py
+++ b/glance/store/base.py
@@ -28,13 +28,13 @@ class Store(object):
 
     CHUNKSIZE = (16 * 1024 * 1024)  # 16M
 
-    def __init__(self, options=None):
+    def __init__(self, conf=None):
         """
         Initialize the Store
 
-        :param options: Optional dictionary of configuration options
+        :param conf: Optional dictionary of configuration options
         """
-        self.options = options or {}
+        self.conf = conf or {}
 
         self.configure()
 
diff --git a/glance/store/filesystem.py b/glance/store/filesystem.py
index 55ee89d9d2..805d5a7766 100644
--- a/glance/store/filesystem.py
+++ b/glance/store/filesystem.py
@@ -115,7 +115,7 @@ class Store(glance.store.base.Store):
                                                       reason=reason)
 
     def _option_get(self, param):
-        result = self.options.get(param)
+        result = self.conf.get(param)
         if not result:
             reason = _("Could not find %s in configuration options.") % param
             logger.error(reason)
diff --git a/glance/store/rbd.py b/glance/store/rbd.py
index 92d0a10efb..465141cff5 100644
--- a/glance/store/rbd.py
+++ b/glance/store/rbd.py
@@ -109,16 +109,16 @@ class Store(glance.store.base.Store):
         """
         try:
             self.chunk_size = int(
-                self.options.get(
+                self.conf.get(
                     'rbd_store_chunk_size',
                     DEFAULT_CHUNKSIZE)) * 1024 * 1024
             # these must not be unicode since they will be passed to a
             # non-unicode-aware C library
-            self.pool = str(self.options.get('rbd_store_pool',
+            self.pool = str(self.conf.get('rbd_store_pool',
                                              DEFAULT_POOL))
-            self.user = str(self.options.get('rbd_store_user',
+            self.user = str(self.conf.get('rbd_store_user',
                                              DEFAULT_USER))
-            self.conf_file = str(self.options.get('rbd_store_ceph_conf',
+            self.conf_file = str(self.conf.get('rbd_store_ceph_conf',
                                                   DEFAULT_CONFFILE))
         except Exception, e:
             reason = _("Error in store configuration: %s") % e
diff --git a/glance/store/s3.py b/glance/store/s3.py
index 73bd567b42..7edac44fee 100644
--- a/glance/store/s3.py
+++ b/glance/store/s3.py
@@ -210,14 +210,14 @@ class Store(glance.store.base.Store):
         else:  # Defaults http
             self.full_s3_host = 'http://' + self.s3_host
 
-        if self.options.get('s3_store_object_buffer_dir'):
-            self.s3_store_object_buffer_dir = self.options.get(
+        if self.conf.get('s3_store_object_buffer_dir'):
+            self.s3_store_object_buffer_dir = self.conf.get(
                 's3_store_object_buffer_dir')
         else:
             self.s3_store_object_buffer_dir = None
 
     def _option_get(self, param):
-        result = self.options.get(param)
+        result = self.conf.get(param)
         if not result:
             reason = _("Could not find %(param)s in configuration "
                        "options.") % locals()
@@ -297,7 +297,7 @@ class Store(glance.store.base.Store):
                                host=loc.s3serviceurl,
                                is_secure=(loc.scheme == 's3+https'))
 
-        create_bucket_if_missing(self.bucket, s3_conn, self.options)
+        create_bucket_if_missing(self.bucket, s3_conn, self.conf)
 
         bucket_obj = get_bucket(s3_conn, self.bucket)
         obj_name = str(image_id)
@@ -403,21 +403,21 @@ def get_bucket(conn, bucket_id):
     return bucket
 
 
-def create_bucket_if_missing(bucket, s3_conn, options):
+def create_bucket_if_missing(bucket, s3_conn, conf):
     """
     Creates a missing bucket in S3 if the
     ``s3_store_create_bucket_on_put`` option is set.
 
     :param bucket: Name of bucket to create
     :param s3_conn: Connection to S3
-    :param options: Option mapping
+    :param conf: Option mapping
     """
     from boto.exception import S3ResponseError
     try:
         s3_conn.get_bucket(bucket)
     except S3ResponseError, e:
         if e.status == httplib.NOT_FOUND:
-            add_bucket = config.get_option(options,
+            add_bucket = config.get_option(conf,
                                 's3_store_create_bucket_on_put',
                                 type='bool', default=False)
             if add_bucket:
diff --git a/glance/store/scrubber.py b/glance/store/scrubber.py
index d6e5fc7cf0..e61e6e88ca 100644
--- a/glance/store/scrubber.py
+++ b/glance/store/scrubber.py
@@ -65,23 +65,23 @@ class Daemon(object):
 class Scrubber(object):
     CLEANUP_FILE = ".cleanup"
 
-    def __init__(self, options):
-        logger.info(_("Initializing scrubber with options: %s") % options)
-        self.options = options
-        self.datadir = config.get_option(options, 'scrubber_datadir')
-        self.cleanup = config.get_option(options, 'cleanup_scrubber',
+    def __init__(self, conf):
+        logger.info(_("Initializing scrubber with conf: %s") % conf)
+        self.conf = conf
+        self.datadir = config.get_option(conf, 'scrubber_datadir')
+        self.cleanup = config.get_option(conf, 'cleanup_scrubber',
                                          type='bool', default=False)
-        host = config.get_option(options, 'registry_host')
-        port = config.get_option(options, 'registry_port', type='int')
+        host = config.get_option(conf, 'registry_host')
+        port = config.get_option(conf, 'registry_port', type='int')
         self.registry = client.RegistryClient(host, port)
 
         utils.safe_mkdirs(self.datadir)
 
         if self.cleanup:
-            self.cleanup_time = config.get_option(options,
+            self.cleanup_time = config.get_option(conf,
                                                   'cleanup_scrubber_time',
                                                   type='int', default=86400)
-        store.create_stores(options)
+        store.create_stores(conf)
 
     def run(self, pool, event=None):
         now = time.time()
diff --git a/glance/store/swift.py b/glance/store/swift.py
index 9c42481263..abe915ebfc 100644
--- a/glance/store/swift.py
+++ b/glance/store/swift.py
@@ -187,7 +187,7 @@ class Store(glance.store.base.Store):
 
     def configure(self):
         self.snet = config.get_option(
-            self.options, 'swift_enable_snet', type='bool', default=False)
+            self.conf, 'swift_enable_snet', type='bool', default=False)
 
     def configure_add(self):
         """
@@ -199,30 +199,30 @@ class Store(glance.store.base.Store):
         self.auth_address = self._option_get('swift_store_auth_address')
         self.user = self._option_get('swift_store_user')
         self.key = self._option_get('swift_store_key')
-        self.container = self.options.get('swift_store_container',
+        self.container = self.conf.get('swift_store_container',
                                           DEFAULT_CONTAINER)
         try:
-            if self.options.get('swift_store_large_object_size'):
+            if self.conf.get('swift_store_large_object_size'):
                 self.large_object_size = int(
-                    self.options.get('swift_store_large_object_size')
+                    self.conf.get('swift_store_large_object_size')
                     ) * (1024 * 1024)  # Size specified in MB in conf files
             else:
                 self.large_object_size = DEFAULT_LARGE_OBJECT_SIZE
 
-            if self.options.get('swift_store_large_object_chunk_size'):
+            if self.conf.get('swift_store_large_object_chunk_size'):
                 self.large_object_chunk_size = int(
-                    self.options.get('swift_store_large_object_chunk_size')
+                    self.conf.get('swift_store_large_object_chunk_size')
                     ) * (1024 * 1024)  # Size specified in MB in conf files
             else:
                 self.large_object_chunk_size = DEFAULT_LARGE_OBJECT_CHUNK_SIZE
 
-            if self.options.get('swift_store_object_buffer_dir'):
+            if self.conf.get('swift_store_object_buffer_dir'):
                 self.swift_store_object_buffer_dir = (
-                    self.options.get('swift_store_object_buffer_dir'))
+                    self.conf.get('swift_store_object_buffer_dir'))
             else:
                 self.swift_store_object_buffer_dir = None
         except Exception, e:
-            reason = _("Error in configuration options: %s") % e
+            reason = _("Error in configuration conf: %s") % e
             logger.error(reason)
             raise exception.BadStoreConfiguration(store_name="swift",
                                                   reason=reason)
@@ -283,7 +283,7 @@ class Store(glance.store.base.Store):
             authurl=auth_url, user=user, key=key, snet=snet)
 
     def _option_get(self, param):
-        result = self.options.get(param)
+        result = self.conf.get(param)
         if not result:
             reason = (_("Could not find %(param)s in configuration "
                         "options.") % locals())
@@ -330,7 +330,7 @@ class Store(glance.store.base.Store):
         swift_conn = self._make_swift_connection(
             auth_url=self.full_auth_address, user=self.user, key=self.key)
 
-        create_container_if_missing(self.container, swift_conn, self.options)
+        create_container_if_missing(self.container, swift_conn, self.conf)
 
         obj_name = str(image_id)
         location = StoreLocation({'scheme': self.scheme,
@@ -482,20 +482,20 @@ class Store(glance.store.base.Store):
                 raise
 
 
-def create_container_if_missing(container, swift_conn, options):
+def create_container_if_missing(container, swift_conn, conf):
     """
     Creates a missing container in Swift if the
     ``swift_store_create_container_on_put`` option is set.
 
     :param container: Name of container to create
     :param swift_conn: Connection to Swift
-    :param options: Option mapping
+    :param conf: Option mapping
     """
     try:
         swift_conn.head_container(container)
     except swift_client.ClientException, e:
         if e.http_status == httplib.NOT_FOUND:
-            add_container = config.get_option(options,
+            add_container = config.get_option(conf,
                                 'swift_store_create_container_on_put',
                                 type='bool', default=False)
             if add_container:
diff --git a/glance/tests/stubs.py b/glance/tests/stubs.py
index 492592342a..1abcfc07d1 100644
--- a/glance/tests/stubs.py
+++ b/glance/tests/stubs.py
@@ -97,9 +97,9 @@ def stub_out_registry_and_store_server(stubs):
             sql_connection = os.environ.get('GLANCE_SQL_CONNECTION',
                                             "sqlite://")
             context_class = 'glance.registry.context.RequestContext'
-            options = {'sql_connection': sql_connection, 'verbose': VERBOSE,
-                       'debug': DEBUG, 'context_class': context_class}
-            api = context.ContextMiddleware(rserver.API(options), options)
+            conf = {'sql_connection': sql_connection, 'verbose': VERBOSE,
+                    'debug': DEBUG, 'context_class': context_class}
+            api = context.ContextMiddleware(rserver.API(conf), conf)
             res = self.req.get_response(api)
 
             # httplib.Response has a read() method...fake it out
@@ -145,17 +145,17 @@ def stub_out_registry_and_store_server(stubs):
                 self.req.body = body
 
         def getresponse(self):
-            options = {'verbose': VERBOSE,
-                       'debug': DEBUG,
-                       'bind_host': '0.0.0.0',
-                       'bind_port': '9999999',
-                       'registry_host': '0.0.0.0',
-                       'registry_port': '9191',
-                       'default_store': 'file',
-                       'filesystem_store_datadir': FAKE_FILESYSTEM_ROOTDIR}
+            conf = {'verbose': VERBOSE,
+                    'debug': DEBUG,
+                    'bind_host': '0.0.0.0',
+                    'bind_port': '9999999',
+                    'registry_host': '0.0.0.0',
+                    'registry_port': '9191',
+                    'default_store': 'file',
+                    'filesystem_store_datadir': FAKE_FILESYSTEM_ROOTDIR}
             api = version_negotiation.VersionNegotiationFilter(
-                context.ContextMiddleware(router.API(options), options),
-                options)
+                context.ContextMiddleware(router.API(conf), conf),
+                conf)
             res = self.req.get_response(api)
 
             # httplib.Response has a read() method...fake it out
@@ -218,9 +218,9 @@ def stub_out_registry_server(stubs, **kwargs):
         def getresponse(self):
             sql_connection = kwargs.get('sql_connection', "sqlite:///")
             context_class = 'glance.registry.context.RequestContext'
-            options = {'sql_connection': sql_connection, 'verbose': VERBOSE,
-                       'debug': DEBUG, 'context_class': context_class}
-            api = context.ContextMiddleware(rserver.API(options), options)
+            conf = {'sql_connection': sql_connection, 'verbose': VERBOSE,
+                    'debug': DEBUG, 'context_class': context_class}
+            api = context.ContextMiddleware(rserver.API(conf), conf)
             res = self.req.get_response(api)
 
             # httplib.Response has a read() method...fake it out
diff --git a/glance/tests/unit/test_api.py b/glance/tests/unit/test_api.py
index 51850469cb..69b4472c23 100644
--- a/glance/tests/unit/test_api.py
+++ b/glance/tests/unit/test_api.py
@@ -42,14 +42,14 @@ UUID1 = _gen_uuid()
 UUID2 = _gen_uuid()
 
 
-OPTIONS = {'sql_connection': 'sqlite://',
-           'verbose': False,
-           'debug': False,
-           'registry_host': '0.0.0.0',
-           'registry_port': '9191',
-           'default_store': 'file',
-           'filesystem_store_datadir': stubs.FAKE_FILESYSTEM_ROOTDIR,
-           'context_class': 'glance.registry.context.RequestContext'}
+CONF = {'sql_connection': 'sqlite://',
+        'verbose': False,
+        'debug': False,
+        'registry_host': '0.0.0.0',
+        'registry_port': '9191',
+        'default_store': 'file',
+        'filesystem_store_datadir': stubs.FAKE_FILESYSTEM_ROOTDIR,
+        'context_class': 'glance.registry.context.RequestContext'}
 
 
 class TestRegistryDb(unittest.TestCase):
@@ -64,15 +64,14 @@ class TestRegistryDb(unittest.TestCase):
         API controller results in a) an Exception being thrown and b)
         a message being logged to the registry log file...
         """
-        bad_options = {'verbose': True,
-                       'debug': True,
-                       'sql_connection': 'baddriver:///'}
+        bad_conf = {'verbose': True,
+                    'debug': True,
+                    'sql_connection': 'baddriver:///'}
         # We set this to None to trigger a reconfigure, otherwise
         # other modules may have already correctly configured the DB
         orig_engine = db_api._ENGINE
         db_api._ENGINE = None
-        self.assertRaises(ImportError, db_api.configure_db,
-                          bad_options)
+        self.assertRaises(ImportError, db_api.configure_db, bad_conf)
         exc_raised = False
         self.log_written = False
 
@@ -82,7 +81,7 @@ class TestRegistryDb(unittest.TestCase):
 
         self.stubs.Set(db_api.logger, 'error', fake_log_error)
         try:
-            api_obj = rserver.API(bad_options)
+            api_obj = rserver.API(bad_conf)
         except ImportError:
             exc_raised = True
         finally:
@@ -102,7 +101,7 @@ class TestRegistryAPI(unittest.TestCase):
         self.stubs = stubout.StubOutForTesting()
         stubs.stub_out_registry_and_store_server(self.stubs)
         stubs.stub_out_filesystem_backend()
-        self.api = context.ContextMiddleware(rserver.API(OPTIONS), OPTIONS)
+        self.api = context.ContextMiddleware(rserver.API(CONF), CONF)
         self.FIXTURES = [
             {'id': UUID1,
              'name': 'fake image #1',
@@ -137,7 +136,7 @@ class TestRegistryAPI(unittest.TestCase):
              'location': "file:///tmp/glance-tests/2",
              'properties': {}}]
         self.context = rcontext.RequestContext(is_admin=True)
-        db_api.configure_db(OPTIONS)
+        db_api.configure_db(CONF)
         self.destroy_fixtures()
         self.create_fixtures()
 
@@ -1936,7 +1935,7 @@ class TestGlanceAPI(unittest.TestCase):
         stubs.stub_out_registry_and_store_server(self.stubs)
         stubs.stub_out_filesystem_backend()
         sql_connection = os.environ.get('GLANCE_SQL_CONNECTION', "sqlite://")
-        self.api = context.ContextMiddleware(router.API(OPTIONS), OPTIONS)
+        self.api = context.ContextMiddleware(router.API(CONF), CONF)
         self.FIXTURES = [
             {'id': UUID1,
              'name': 'fake image #1',
@@ -1967,7 +1966,7 @@ class TestGlanceAPI(unittest.TestCase):
              'location': "file:///tmp/glance-tests/2",
              'properties': {}}]
         self.context = rcontext.RequestContext(is_admin=True)
-        db_api.configure_db(OPTIONS)
+        db_api.configure_db(CONF)
         self.destroy_fixtures()
         self.create_fixtures()
 
diff --git a/glance/tests/unit/test_clients.py b/glance/tests/unit/test_clients.py
index f702798333..8361cc8b41 100644
--- a/glance/tests/unit/test_clients.py
+++ b/glance/tests/unit/test_clients.py
@@ -35,7 +35,7 @@ from glance.registry import client as rclient
 from glance.registry import context as rcontext
 from glance.tests import stubs
 
-OPTIONS = {'sql_connection': 'sqlite://'}
+CONF = {'sql_connection': 'sqlite://'}
 
 _gen_uuid = utils.generate_uuid
 
@@ -138,7 +138,7 @@ class TestRegistryClient(unittest.TestCase):
         """Establish a clean test environment"""
         self.stubs = stubout.StubOutForTesting()
         stubs.stub_out_registry_and_store_server(self.stubs)
-        db_api.configure_db(OPTIONS)
+        db_api.configure_db(CONF)
         self.context = rcontext.RequestContext(is_admin=True)
         self.FIXTURES = [
             {'id': UUID1,
@@ -1138,7 +1138,7 @@ class TestClient(unittest.TestCase):
         self.stubs = stubout.StubOutForTesting()
         stubs.stub_out_registry_and_store_server(self.stubs)
         stubs.stub_out_filesystem_backend()
-        db_api.configure_db(OPTIONS)
+        db_api.configure_db(CONF)
         self.client = client.Client("0.0.0.0")
         self.FIXTURES = [
             {'id': UUID1,
diff --git a/glance/tests/unit/test_config.py b/glance/tests/unit/test_config.py
index 1ebe250275..d85819f957 100644
--- a/glance/tests/unit/test_config.py
+++ b/glance/tests/unit/test_config.py
@@ -48,21 +48,21 @@ class TestOptionParsing(unittest.TestCase):
         # of typed values
         parser = optparse.OptionParser()
         config.add_common_options(parser)
-        parsed_options, args = config.parse_options(parser, [])
+        parsed_conf, args = config.parse_options(parser, [])
 
-        expected_options = {'verbose': False, 'debug': False,
-                            'config_file': None}
-        self.assertEquals(expected_options, parsed_options)
+        expected_conf = {'verbose': False, 'debug': False,
+                         'config_file': None}
+        self.assertEquals(expected_conf, parsed_conf)
 
         # test non-empty args and that parse_options() returns a mapping
         # of typed values matching supplied args
         parser = optparse.OptionParser()
         config.add_common_options(parser)
-        parsed_options, args = config.parse_options(parser, ['--verbose'])
+        parsed_conf, args = config.parse_options(parser, ['--verbose'])
 
-        expected_options = {'verbose': True, 'debug': False,
-                            'config_file': None}
-        self.assertEquals(expected_options, parsed_options)
+        expected_conf = {'verbose': True, 'debug': False,
+                         'config_file': None}
+        self.assertEquals(expected_conf, parsed_conf)
 
         # test non-empty args that contain unknown options raises
         # a SystemExit exception. Not ideal, but unfortunately optparse
diff --git a/glance/tests/unit/test_filesystem_store.py b/glance/tests/unit/test_filesystem_store.py
index 64e8d6161d..24c930b7ab 100644
--- a/glance/tests/unit/test_filesystem_store.py
+++ b/glance/tests/unit/test_filesystem_store.py
@@ -29,7 +29,7 @@ from glance.store.location import get_location_from_uri
 from glance.store.filesystem import Store, ChunkedFile
 from glance.tests import stubs
 
-FILESYSTEM_OPTIONS = {
+FILESYSTEM_CONF = {
     'verbose': True,
     'debug': True,
     'filesystem_store_datadir': stubs.FAKE_FILESYSTEM_ROOTDIR}
@@ -43,7 +43,7 @@ class TestStore(unittest.TestCase):
         stubs.stub_out_filesystem_backend()
         self.orig_chunksize = ChunkedFile.CHUNKSIZE
         ChunkedFile.CHUNKSIZE = 10
-        self.store = Store(FILESYSTEM_OPTIONS)
+        self.store = Store(FILESYSTEM_CONF)
 
     def tearDown(self):
         """Clear the test environment"""
@@ -116,9 +116,6 @@ class TestStore(unittest.TestCase):
         raises an appropriate exception
         """
         image_file = StringIO.StringIO("nevergonnamakeit")
-        options = {'verbose': True,
-                   'debug': True,
-                   'filesystem_store_datadir': stubs.FAKE_FILESYSTEM_ROOTDIR}
         self.assertRaises(exception.Duplicate,
                           self.store.add,
                           '2', image_file, 0)
diff --git a/glance/tests/unit/test_image_cache.py b/glance/tests/unit/test_image_cache.py
index 1237142780..ad0c870f88 100644
--- a/glance/tests/unit/test_image_cache.py
+++ b/glance/tests/unit/test_image_cache.py
@@ -136,7 +136,7 @@ class ImageCacheTestCase(object):
 
         self.assertTrue(os.path.exists(incomplete_file_path))
 
-        self.cache.options['image_cache_stall_time'] = 0
+        self.cache.conf['image_cache_stall_time'] = 0
         self.cache.clean()
 
         self.assertFalse(os.path.exists(incomplete_file_path))
@@ -250,12 +250,12 @@ class TestImageCacheXattr(unittest.TestCase,
 
         self.inited = True
         self.disabled = False
-        self.options = {'image_cache_dir': self.cache_dir,
-                        'image_cache_driver': 'xattr',
-                        'image_cache_max_size': 1024 * 5,
-                        'registry_host': '0.0.0.0',
-                        'registry_port': 9191}
-        self.cache = image_cache.ImageCache(self.options)
+        self.conf = {'image_cache_dir': self.cache_dir,
+                     'image_cache_driver': 'xattr',
+                     'image_cache_max_size': 1024 * 5,
+                     'registry_host': '0.0.0.0',
+                     'registry_port': 9191}
+        self.cache = image_cache.ImageCache(self.conf)
 
         if not xattr_writes_supported(self.cache_dir):
             self.inited = True
@@ -294,12 +294,12 @@ class TestImageCacheSqlite(unittest.TestCase,
         self.disabled = False
         self.cache_dir = os.path.join("/", "tmp", "test.cache.%d" %
                                       random.randint(0, 1000000))
-        self.options = {'image_cache_dir': self.cache_dir,
-                        'image_cache_driver': 'sqlite',
-                        'image_cache_max_size': 1024 * 5,
-                        'registry_host': '0.0.0.0',
-                        'registry_port': 9191}
-        self.cache = image_cache.ImageCache(self.options)
+        self.conf = {'image_cache_dir': self.cache_dir,
+                     'image_cache_driver': 'sqlite',
+                     'image_cache_max_size': 1024 * 5,
+                     'registry_host': '0.0.0.0',
+                     'registry_port': 9191}
+        self.cache = image_cache.ImageCache(self.conf)
 
     def tearDown(self):
         if os.path.exists(self.cache_dir):
diff --git a/glance/tests/unit/test_migrations.py b/glance/tests/unit/test_migrations.py
index 0ab47554a2..2402cb6e94 100644
--- a/glance/tests/unit/test_migrations.py
+++ b/glance/tests/unit/test_migrations.py
@@ -124,10 +124,10 @@ class TestMigrations(unittest.TestCase):
         that there are no errors in the version scripts for each engine
         """
         for key, engine in self.engines.items():
-            options = {'sql_connection': TestMigrations.TEST_DATABASES[key]}
-            self._walk_versions(options)
+            conf = {'sql_connection': TestMigrations.TEST_DATABASES[key]}
+            self._walk_versions(conf)
 
-    def _walk_versions(self, options):
+    def _walk_versions(self, conf):
         # Determine latest version script from the repo, then
         # upgrade from 1 through to the latest, with no data
         # in the databases. This just checks that the schema itself
@@ -136,24 +136,24 @@ class TestMigrations(unittest.TestCase):
         # Assert we are not under version control...
         self.assertRaises(exception.DatabaseMigrationError,
                           migration_api.db_version,
-                          options)
+                          conf)
         # Place the database under version control
-        migration_api.version_control(options)
+        migration_api.version_control(conf)
 
-        cur_version = migration_api.db_version(options)
+        cur_version = migration_api.db_version(conf)
         self.assertEqual(0, cur_version)
 
         for version in xrange(1, TestMigrations.REPOSITORY.latest + 1):
-            migration_api.upgrade(options, version)
-            cur_version = migration_api.db_version(options)
+            migration_api.upgrade(conf, version)
+            cur_version = migration_api.db_version(conf)
             self.assertEqual(cur_version, version)
 
         # Now walk it back down to 0 from the latest, testing
         # the downgrade paths.
         for version in reversed(
             xrange(0, TestMigrations.REPOSITORY.latest)):
-            migration_api.downgrade(options, version)
-            cur_version = migration_api.db_version(options)
+            migration_api.downgrade(conf, version)
+            cur_version = migration_api.db_version(conf)
             self.assertEqual(cur_version, version)
 
     def test_no_data_loss_2_to_3_to_2(self):
@@ -165,14 +165,14 @@ class TestMigrations(unittest.TestCase):
         the image_properties table back into the base image table.
         """
         for key, engine in self.engines.items():
-            options = {'sql_connection': TestMigrations.TEST_DATABASES[key]}
-            self._no_data_loss_2_to_3_to_2(engine, options)
+            conf = {'sql_connection': TestMigrations.TEST_DATABASES[key]}
+            self._no_data_loss_2_to_3_to_2(engine, conf)
 
-    def _no_data_loss_2_to_3_to_2(self, engine, options):
-        migration_api.version_control(options)
-        migration_api.upgrade(options, 2)
+    def _no_data_loss_2_to_3_to_2(self, engine, conf):
+        migration_api.version_control(conf)
+        migration_api.upgrade(conf, 2)
 
-        cur_version = migration_api.db_version(options)
+        cur_version = migration_api.db_version(conf)
         self.assertEquals(2, cur_version)
 
         # We are now on version 2. Check that the images table does
@@ -214,9 +214,9 @@ class TestMigrations(unittest.TestCase):
         # Now let's upgrade to 3. This should move the type column
         # to the image_properties table as type properties.
 
-        migration_api.upgrade(options, 3)
+        migration_api.upgrade(conf, 3)
 
-        cur_version = migration_api.db_version(options)
+        cur_version = migration_api.db_version(conf)
         self.assertEquals(3, cur_version)
 
         images_table = Table('images', MetaData(), autoload=True,
@@ -240,7 +240,7 @@ class TestMigrations(unittest.TestCase):
         # Downgrade to 2 and check that the type properties were moved
         # to the main image table
 
-        migration_api.downgrade(options, 2)
+        migration_api.downgrade(conf, 2)
 
         images_table = Table('images', MetaData(), autoload=True,
                              autoload_with=engine)
diff --git a/glance/tests/unit/test_notifier.py b/glance/tests/unit/test_notifier.py
index 246800a361..fc0c305c85 100644
--- a/glance/tests/unit/test_notifier.py
+++ b/glance/tests/unit/test_notifier.py
@@ -26,20 +26,20 @@ class TestInvalidNotifier(unittest.TestCase):
     """Test that notifications are generated appropriately"""
 
     def test_cannot_create(self):
-        options = {"notifier_strategy": "invalid_notifier"}
+        conf = {"notifier_strategy": "invalid_notifier"}
         self.assertRaises(exception.InvalidNotifierStrategy,
                           notifier.Notifier,
-                          options)
+                          conf)
 
 
 class TestLoggingNotifier(unittest.TestCase):
     """Test the logging notifier is selected and works properly."""
 
     def setUp(self):
-        options = {"notifier_strategy": "logging"}
+        conf = {"notifier_strategy": "logging"}
         self.called = False
         self.logger = logging.getLogger("glance.notifier.logging_notifier")
-        self.notifier = notifier.Notifier(options)
+        self.notifier = notifier.Notifier(conf)
 
     def _called(self, msg):
         self.called = msg
@@ -67,8 +67,8 @@ class TestNoopNotifier(unittest.TestCase):
     """Test that the noop notifier works...and does nothing?"""
 
     def setUp(self):
-        options = {"notifier_strategy": "noop"}
-        self.notifier = notifier.Notifier(options)
+        conf = {"notifier_strategy": "noop"}
+        self.notifier = notifier.Notifier(conf)
 
     def test_warn(self):
         self.notifier.warn("test_event", "test_message")
@@ -86,8 +86,8 @@ class TestRabbitNotifier(unittest.TestCase):
     def setUp(self):
         notifier.RabbitStrategy._send_message = self._send_message
         self.called = False
-        options = {"notifier_strategy": "rabbit"}
-        self.notifier = notifier.Notifier(options)
+        conf = {"notifier_strategy": "rabbit"}
+        self.notifier = notifier.Notifier(conf)
 
     def _send_message(self, message, priority):
         self.called = {
diff --git a/glance/tests/unit/test_s3_store.py b/glance/tests/unit/test_s3_store.py
index e8be5d34ed..bf9d171fb3 100644
--- a/glance/tests/unit/test_s3_store.py
+++ b/glance/tests/unit/test_s3_store.py
@@ -37,12 +37,12 @@ from glance.store.s3 import Store
 FAKE_UUID = utils.generate_uuid()
 
 FIVE_KB = (5 * 1024)
-S3_OPTIONS = {'verbose': True,
-              'debug': True,
-              's3_store_access_key': 'user',
-              's3_store_secret_key': 'key',
-              's3_store_host': 'localhost:8080',
-              's3_store_bucket': 'glance'}
+S3_CONF = {'verbose': True,
+           'debug': True,
+           's3_store_access_key': 'user',
+           's3_store_secret_key': 'key',
+           's3_store_host': 'localhost:8080',
+           's3_store_bucket': 'glance'}
 
 
 # We stub out as little as possible to ensure that the code paths
@@ -163,7 +163,7 @@ class TestStore(unittest.TestCase):
         """Establish a clean test environment"""
         self.stubs = stubout.StubOutForTesting()
         stub_out_s3(self.stubs)
-        self.store = Store(S3_OPTIONS)
+        self.store = Store(S3_CONF)
 
     def tearDown(self):
         """Clear the test environment"""
@@ -204,10 +204,10 @@ class TestStore(unittest.TestCase):
         expected_s3_contents = "*" * expected_s3_size
         expected_checksum = hashlib.md5(expected_s3_contents).hexdigest()
         expected_location = format_s3_location(
-            S3_OPTIONS['s3_store_access_key'],
-            S3_OPTIONS['s3_store_secret_key'],
-            S3_OPTIONS['s3_store_host'],
-            S3_OPTIONS['s3_store_bucket'],
+            S3_CONF['s3_store_access_key'],
+            S3_CONF['s3_store_secret_key'],
+            S3_CONF['s3_store_host'],
+            S3_CONF['s3_store_bucket'],
             expected_image_id)
         image_s3 = StringIO.StringIO(expected_s3_contents)
 
@@ -250,17 +250,17 @@ class TestStore(unittest.TestCase):
             expected_s3_contents = "*" * expected_s3_size
             expected_checksum = \
                     hashlib.md5(expected_s3_contents).hexdigest()
-            new_options = S3_OPTIONS.copy()
-            new_options['s3_store_host'] = variation
+            new_conf = S3_CONF.copy()
+            new_conf['s3_store_host'] = variation
             expected_location = format_s3_location(
-                new_options['s3_store_access_key'],
-                new_options['s3_store_secret_key'],
-                new_options['s3_store_host'],
-                new_options['s3_store_bucket'],
+                new_conf['s3_store_access_key'],
+                new_conf['s3_store_secret_key'],
+                new_conf['s3_store_host'],
+                new_conf['s3_store_bucket'],
                 expected_image_id)
             image_s3 = StringIO.StringIO(expected_s3_contents)
 
-            self.store = Store(new_options)
+            self.store = Store(new_conf)
             location, size, checksum = self.store.add(expected_image_id,
                                                       image_s3,
                                                       expected_s3_size)
@@ -288,11 +288,11 @@ class TestStore(unittest.TestCase):
                           FAKE_UUID, image_s3, 0)
 
     def _option_required(self, key):
-        options = S3_OPTIONS.copy()
-        del options[key]
+        conf = S3_CONF.copy()
+        del conf[key]
 
         try:
-            self.store = Store(options)
+            self.store = Store(conf)
             return self.store.add == self.store.add_disabled
         except:
             return False
diff --git a/glance/tests/unit/test_swift_store.py b/glance/tests/unit/test_swift_store.py
index 61628ee6d3..fc2a6771c3 100644
--- a/glance/tests/unit/test_swift_store.py
+++ b/glance/tests/unit/test_swift_store.py
@@ -38,12 +38,12 @@ Store = glance.store.swift.Store
 FIVE_KB = (5 * 1024)
 FIVE_GB = (5 * 1024 * 1024 * 1024)
 MAX_SWIFT_OBJECT_SIZE = FIVE_GB
-SWIFT_OPTIONS = {'verbose': True,
-                 'debug': True,
-                 'swift_store_user': 'user',
-                 'swift_store_key': 'key',
-                 'swift_store_auth_address': 'localhost:8080',
-                 'swift_store_container': 'glance'}
+SWIFT_CONF = {'verbose': True,
+              'debug': True,
+              'swift_store_user': 'user',
+              'swift_store_key': 'key',
+              'swift_store_auth_address': 'localhost:8080',
+              'swift_store_container': 'glance'}
 
 
 # We stub out as little as possible to ensure that the code paths
@@ -182,7 +182,7 @@ class TestStore(unittest.TestCase):
         """Establish a clean test environment"""
         self.stubs = stubout.StubOutForTesting()
         stub_out_swift_common_client(self.stubs)
-        self.store = Store(SWIFT_OPTIONS)
+        self.store = Store(SWIFT_CONF)
 
     def tearDown(self):
         """Clear the test environment"""
@@ -288,12 +288,12 @@ class TestStore(unittest.TestCase):
             expected_swift_contents = "*" * expected_swift_size
             expected_checksum = \
                     hashlib.md5(expected_swift_contents).hexdigest()
-            new_options = SWIFT_OPTIONS.copy()
-            new_options['swift_store_auth_address'] = variation
+            new_conf = SWIFT_CONF.copy()
+            new_conf['swift_store_auth_address'] = variation
 
             image_swift = StringIO.StringIO(expected_swift_contents)
 
-            self.store = Store(new_options)
+            self.store = Store(new_conf)
             location, size, checksum = self.store.add(image_id, image_swift,
                                                       expected_swift_size)
 
@@ -314,11 +314,11 @@ class TestStore(unittest.TestCase):
         Tests that adding an image with a non-existing container
         raises an appropriate exception
         """
-        options = SWIFT_OPTIONS.copy()
-        options['swift_store_create_container_on_put'] = 'False'
-        options['swift_store_container'] = 'noexist'
+        conf = SWIFT_CONF.copy()
+        conf['swift_store_create_container_on_put'] = 'False'
+        conf['swift_store_container'] = 'noexist'
         image_swift = StringIO.StringIO("nevergonnamakeit")
-        self.store = Store(options)
+        self.store = Store(conf)
 
         # We check the exception text to ensure the container
         # missing text is found in it, otherwise, we would have
@@ -337,9 +337,9 @@ class TestStore(unittest.TestCase):
         Tests that adding an image with a non-existing container
         creates the container automatically if flag is set
         """
-        options = SWIFT_OPTIONS.copy()
-        options['swift_store_create_container_on_put'] = 'True'
-        options['swift_store_container'] = 'noexist'
+        conf = SWIFT_CONF.copy()
+        conf['swift_store_create_container_on_put'] = 'True'
+        conf['swift_store_container'] = 'noexist'
         expected_swift_size = FIVE_KB
         expected_swift_contents = "*" * expected_swift_size
         expected_checksum = hashlib.md5(expected_swift_contents).hexdigest()
@@ -348,7 +348,7 @@ class TestStore(unittest.TestCase):
                             '/noexist/%s' % expected_image_id
         image_swift = StringIO.StringIO(expected_swift_contents)
 
-        self.store = Store(options)
+        self.store = Store(conf)
         location, size, checksum = self.store.add(expected_image_id,
                                                   image_swift,
                                                   expected_swift_size)
@@ -372,8 +372,8 @@ class TestStore(unittest.TestCase):
         and then verify that there have been a number of calls to
         put_object()...
         """
-        options = SWIFT_OPTIONS.copy()
-        options['swift_store_container'] = 'glance'
+        conf = SWIFT_CONF.copy()
+        conf['swift_store_container'] = 'glance'
         expected_swift_size = FIVE_KB
         expected_swift_contents = "*" * expected_swift_size
         expected_checksum = hashlib.md5(expected_swift_contents).hexdigest()
@@ -387,7 +387,7 @@ class TestStore(unittest.TestCase):
         try:
             glance.store.swift.DEFAULT_LARGE_OBJECT_SIZE = 1024
             glance.store.swift.DEFAULT_LARGE_OBJECT_CHUNK_SIZE = 1024
-            self.store = Store(options)
+            self.store = Store(conf)
             location, size, checksum = self.store.add(expected_image_id,
                                                       image_swift,
                                                       expected_swift_size)
@@ -418,8 +418,8 @@ class TestStore(unittest.TestCase):
 
         Bug lp:891738
         """
-        options = SWIFT_OPTIONS.copy()
-        options['swift_store_container'] = 'glance'
+        conf = SWIFT_CONF.copy()
+        conf['swift_store_container'] = 'glance'
 
         # Set up a 'large' image of 5KB
         expected_swift_size = FIVE_KB
@@ -440,7 +440,7 @@ class TestStore(unittest.TestCase):
             MAX_SWIFT_OBJECT_SIZE = 1024
             glance.store.swift.DEFAULT_LARGE_OBJECT_SIZE = 1024
             glance.store.swift.DEFAULT_LARGE_OBJECT_CHUNK_SIZE = 1024
-            self.store = Store(options)
+            self.store = Store(conf)
             location, size, checksum = self.store.add(expected_image_id,
                                                       image_swift, 0)
         finally:
@@ -471,11 +471,11 @@ class TestStore(unittest.TestCase):
                           FAKE_UUID, image_swift, 0)
 
     def _option_required(self, key):
-        options = SWIFT_OPTIONS.copy()
-        del options[key]
+        conf = SWIFT_CONF.copy()
+        del conf[key]
 
         try:
-            self.store = Store(options)
+            self.store = Store(conf)
             return self.store.add == self.store.add_disabled
         except:
             return False
diff --git a/glance/tests/unit/test_versions.py b/glance/tests/unit/test_versions.py
index cdf25917b7..9032e4e322 100644
--- a/glance/tests/unit/test_versions.py
+++ b/glance/tests/unit/test_versions.py
@@ -46,9 +46,9 @@ class VersionsTest(unittest.TestCase):
     def test_get_version_list(self):
         req = webob.Request.blank('/')
         req.accept = "application/json"
-        options = {'bind_host': '0.0.0.0',
-                   'bind_port': 9292}
-        res = req.get_response(versions.Controller(options))
+        conf = {'bind_host': '0.0.0.0',
+                'bind_port': 9292}
+        res = req.get_response(versions.Controller(conf))
         self.assertEqual(res.status_int, 300)
         self.assertEqual(res.content_type, "application/json")
         results = json.loads(res.body)["versions"]