Refactor: get rid of keystone/config.py

- The file was unnecessary and the name was confusing.
- Replaced all uses of config.SERVICE with direct references to the
  IdentityService class (which will probably need to be refactored
  away as well).

Change-Id: Id65c2f231376ed76a631e51d91f17023b98636e9

9 files changed, 58 insertions, 65 deletions

diff --git a/keystone/config.py b/keystone/config.py
deleted file mode 100644
index 22dd6540..00000000
--- a/keystone/config.py
+++ /dev/null
@@ -1,8 +0,0 @@
-"""TODO: This file should be dissolved"""
-
-from keystone.logic.service import IdentityService
-SERVICE = IdentityService()
-
-# These just need to be imported somewhere, nothing appears to access them?
-from keystone.backends import sqlalchemy
-SQLALCHEMY = sqlalchemy
diff --git a/keystone/controllers/credentials.py b/keystone/controllers/credentials.py
index b1de7635..c4a01be6 100644
--- a/keystone/controllers/credentials.py
+++ b/keystone/controllers/credentials.py
@@ -1,6 +1,6 @@
 from keystone import utils
 from keystone.common import wsgi
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from keystone.logic.types.credential import PasswordCredentials
 from . import get_marker_limit_and_url
 
@@ -13,19 +13,19 @@ class CredentialsController(wsgi.Controller):
     @utils.wrap_error
     def get_credentials(self, req, user_id):
         marker, limit, url = get_marker_limit_and_url(req)
-        credentials = config.SERVICE.get_credentials(
+        credentials = IdentityService.get_credentials(
             utils.get_auth_token(req), user_id, marker, limit, url)
         return utils.send_result(200, req, credentials)
 
     @utils.wrap_error
     def get_password_credential(self, req, user_id):
-        credentials = config.SERVICE.get_password_credentials(
+        credentials = IdentityService.get_password_credentials(
             utils.get_auth_token(req), user_id)
         return utils.send_result(200, req, credentials)
 
     @utils.wrap_error
     def delete_password_credential(self, req, user_id):
-        config.SERVICE.delete_password_credentials(utils.get_auth_token(req),
+        IdentityService.delete_password_credentials(utils.get_auth_token(req),
             user_id)
         return utils.send_result(204, None)
 
@@ -33,7 +33,7 @@ class CredentialsController(wsgi.Controller):
     def add_credential(self, req, user_id):
         credential = utils.get_normalized_request_content(
             PasswordCredentials, req)
-        credential = config.SERVICE.create_password_credentials(
+        credential = IdentityService.create_password_credentials(
             utils.get_auth_token(req), user_id, credential)
         return utils.send_result(201, req, credential)
 
@@ -41,6 +41,6 @@ class CredentialsController(wsgi.Controller):
     def update_password_credential(self, req, user_id):
         credential = utils.get_normalized_request_content(
             PasswordCredentials, req)
-        credential = config.SERVICE.update_password_credentials(
+        credential = IdentityService.update_password_credentials(
             utils.get_auth_token(req), user_id, credential)
         return utils.send_result(200, req, credential)
diff --git a/keystone/controllers/endpointtemplates.py b/keystone/controllers/endpointtemplates.py
index ad7c468a..8fc1e104 100644
--- a/keystone/controllers/endpointtemplates.py
+++ b/keystone/controllers/endpointtemplates.py
@@ -1,6 +1,6 @@
 from keystone import utils
 from keystone.common import wsgi
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from keystone.logic.types.endpoint import EndpointTemplate
 from . import get_marker_limit_and_url
 
@@ -16,11 +16,11 @@ class EndpointTemplatesController(wsgi.Controller):
         marker, limit, url = get_marker_limit_and_url(req)
         service_id = req.GET["serviceId"] if "serviceId" in req.GET else None
         if service_id:
-            endpoint_templates = config.SERVICE.\
+            endpoint_templates = IdentityService.\
                 get_endpoint_templates_by_service(
                 utils.get_auth_token(req), service_id, marker, limit, url)
         else:
-            endpoint_templates = config.SERVICE.get_endpoint_templates(
+            endpoint_templates = IdentityService.get_endpoint_templates(
                 utils.get_auth_token(req), marker, limit, url)
         return utils.send_result(200, req, endpoint_templates)
 
@@ -29,7 +29,7 @@ class EndpointTemplatesController(wsgi.Controller):
         endpoint_template = utils.get_normalized_request_content(
             EndpointTemplate, req)
         return utils.send_result(201, req,
-            config.SERVICE.add_endpoint_template(utils.get_auth_token(req),
+            IdentityService.add_endpoint_template(utils.get_auth_token(req),
                 endpoint_template))
 
     @utils.wrap_error
@@ -37,26 +37,26 @@ class EndpointTemplatesController(wsgi.Controller):
         endpoint_template = utils.\
             get_normalized_request_content(EndpointTemplate, req)
         return utils.send_result(201, req,
-            config.SERVICE.modify_endpoint_template(\
+            IdentityService.modify_endpoint_template(\
             utils.get_auth_token(req),
             endpoint_template_id, endpoint_template))
 
     @utils.wrap_error
     def delete_endpoint_template(self, req, endpoint_template_id):
-        rval = config.SERVICE.delete_endpoint_template(
+        rval = IdentityService.delete_endpoint_template(
             utils.get_auth_token(req), endpoint_template_id)
         return utils.send_result(204, req, rval)
 
     @utils.wrap_error
     def get_endpoint_template(self, req, endpoint_template_id):
-        endpoint_template = config.SERVICE.get_endpoint_template(
+        endpoint_template = IdentityService.get_endpoint_template(
             utils.get_auth_token(req), endpoint_template_id)
         return utils.send_result(200, req, endpoint_template)
 
     @utils.wrap_error
     def get_endpoints_for_tenant(self, req, tenant_id):
         marker, limit, url = get_marker_limit_and_url(req)
-        endpoints = config.SERVICE.get_tenant_endpoints(
+        endpoints = IdentityService.get_tenant_endpoints(
             utils.get_auth_token(req), marker, limit, url, tenant_id)
         return utils.send_result(200, req, endpoints)
 
@@ -64,11 +64,11 @@ class EndpointTemplatesController(wsgi.Controller):
     def add_endpoint_to_tenant(self, req, tenant_id):
         endpoint = utils.get_normalized_request_content(EndpointTemplate, req)
         return utils.send_result(201, req,
-            config.SERVICE.create_endpoint_for_tenant(
+            IdentityService.create_endpoint_for_tenant(
                 utils.get_auth_token(req), tenant_id, endpoint))
 
     @utils.wrap_error
     def remove_endpoint_from_tenant(self, req, tenant_id, endpoint_id):
-        rval = config.SERVICE.delete_endpoint(utils.get_auth_token(req),
+        rval = IdentityService.delete_endpoint(utils.get_auth_token(req),
                                         endpoint_id)
         return utils.send_result(204, req, rval)
diff --git a/keystone/controllers/roles.py b/keystone/controllers/roles.py
index 44c538d8..67035a1d 100644
--- a/keystone/controllers/roles.py
+++ b/keystone/controllers/roles.py
@@ -1,7 +1,7 @@
 from keystone import utils
 from keystone.common import wsgi
 from keystone.logic.types.role import Role
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from . import get_marker_limit_and_url
 
 
@@ -16,46 +16,46 @@ class RolesController(wsgi.Controller):
     def create_role(self, req):
         role = utils.get_normalized_request_content(Role, req)
         return utils.send_result(201, req,
-            config.SERVICE.create_role(utils.get_auth_token(req), role))
+            IdentityService.create_role(utils.get_auth_token(req), role))
 
     @utils.wrap_error
     def delete_role(self, req, role_id):
-        rval = config.SERVICE.delete_role(utils.get_auth_token(req), role_id)
+        rval = IdentityService.delete_role(utils.get_auth_token(req), role_id)
         return utils.send_result(204, req, rval)
 
     @utils.wrap_error
     def get_roles(self, req):
         role_name = req.GET["name"] if "name" in req.GET else None
         if role_name:
-            tenant = config.SERVICE.get_role_by_name(
+            tenant = IdentityService.get_role_by_name(
                 utils.get_auth_token(req), role_name)
             return utils.send_result(200, req, tenant)
         else:
             marker, limit, url = get_marker_limit_and_url(req)
-            roles = config.SERVICE.get_roles(
+            roles = IdentityService.get_roles(
                 utils.get_auth_token(req), marker, limit, url)
             return utils.send_result(200, req, roles)
 
     @utils.wrap_error
     def get_role(self, req, role_id):
-        role = config.SERVICE.get_role(utils.get_auth_token(req), role_id)
+        role = IdentityService.get_role(utils.get_auth_token(req), role_id)
         return utils.send_result(200, req, role)
 
     @utils.wrap_error
     def add_role_to_user(self, req, user_id, role_id, tenant_id=None):
-        config.SERVICE.add_role_to_user(utils.get_auth_token(req),
+        IdentityService.add_role_to_user(utils.get_auth_token(req),
             user_id, role_id, tenant_id)
         return utils.send_result(201, None)
 
     @utils.wrap_error
     def delete_role_from_user(self, req, user_id, role_id, tenant_id=None):
-        config.SERVICE.remove_role_from_user(utils.get_auth_token(req),
+        IdentityService.remove_role_from_user(utils.get_auth_token(req),
             user_id, role_id, tenant_id)
         return utils.send_result(204, req, None)
 
     @utils.wrap_error
     def get_user_roles(self, req, user_id, tenant_id=None):
         marker, limit, url = get_marker_limit_and_url(req)
-        roles = config.SERVICE.get_user_roles(
+        roles = IdentityService.get_user_roles(
             utils.get_auth_token(req), marker, limit, url, user_id, tenant_id)
         return utils.send_result(200, req, roles)
diff --git a/keystone/controllers/services.py b/keystone/controllers/services.py
index 060fb90a..02fd6b97 100755
--- a/keystone/controllers/services.py
+++ b/keystone/controllers/services.py
@@ -1,7 +1,7 @@
 from keystone import utils
 from keystone.common import wsgi
 from keystone.logic.types.service import Service
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from . import get_marker_limit_and_url
 
 
@@ -15,29 +15,29 @@ class ServicesController(wsgi.Controller):
     def create_service(self, req):
         service = utils.get_normalized_request_content(Service, req)
         return utils.send_result(201, req,
-            config.SERVICE.create_service(utils.get_auth_token(req), service))
+            IdentityService.create_service(utils.get_auth_token(req), service))
 
     @utils.wrap_error
     def get_services(self, req):
         service_name = req.GET["name"] if "name" in req.GET else None
         if service_name:
-            tenant = config.SERVICE.get_service_by_name(
+            tenant = IdentityService.get_service_by_name(
                     utils.get_auth_token(req), service_name)
             return utils.send_result(200, req, tenant)
         else:
             marker, limit, url = get_marker_limit_and_url(req)
-            services = config.SERVICE.get_services(
+            services = IdentityService.get_services(
                 utils.get_auth_token(req), marker, limit, url)
             return utils.send_result(200, req, services)
 
     @utils.wrap_error
     def get_service(self, req, service_id):
-        service = config.SERVICE.get_service(
+        service = IdentityService.get_service(
             utils.get_auth_token(req), service_id)
         return utils.send_result(200, req, service)
 
     @utils.wrap_error
     def delete_service(self, req, service_id):
-        rval = config.SERVICE.delete_service(utils.get_auth_token(req),
+        rval = IdentityService.delete_service(utils.get_auth_token(req),
             service_id)
         return utils.send_result(204, req, rval)
diff --git a/keystone/controllers/tenant.py b/keystone/controllers/tenant.py
index 3ca69e1e..2ca3b499 100644
--- a/keystone/controllers/tenant.py
+++ b/keystone/controllers/tenant.py
@@ -1,6 +1,6 @@
 from keystone import utils
 from keystone.common import wsgi
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from keystone.logic.types.tenant import Tenant
 from . import get_marker_limit_and_url
 
@@ -16,37 +16,37 @@ class TenantController(wsgi.Controller):
     def create_tenant(self, req):
         tenant = utils.get_normalized_request_content(Tenant, req)
         return utils.send_result(201, req,
-            config.SERVICE.create_tenant(utils.get_auth_token(req), tenant))
+            IdentityService.create_tenant(utils.get_auth_token(req), tenant))
 
     @utils.wrap_error
     def get_tenants(self, req):
         tenant_name = req.GET["name"] if "name" in req.GET else None
         if tenant_name:
-            tenant = config.SERVICE.get_tenant_by_name(
+            tenant = IdentityService.get_tenant_by_name(
                 utils.get_auth_token(req),
                 tenant_name)
             return utils.send_result(200, req, tenant)
         else:
             marker, limit, url = get_marker_limit_and_url(req)
-            tenants = config.SERVICE.get_tenants(utils.get_auth_token(req),
+            tenants = IdentityService.get_tenants(utils.get_auth_token(req),
                 marker, limit, url, self.is_service_operation)
             return utils.send_result(200, req, tenants)
 
     @utils.wrap_error
     def get_tenant(self, req, tenant_id):
-        tenant = config.SERVICE.get_tenant(utils.get_auth_token(req),
+        tenant = IdentityService.get_tenant(utils.get_auth_token(req),
             tenant_id)
         return utils.send_result(200, req, tenant)
 
     @utils.wrap_error
     def update_tenant(self, req, tenant_id):
         tenant = utils.get_normalized_request_content(Tenant, req)
-        rval = config.SERVICE.update_tenant(utils.get_auth_token(req),
+        rval = IdentityService.update_tenant(utils.get_auth_token(req),
             tenant_id, tenant)
         return utils.send_result(200, req, rval)
 
     @utils.wrap_error
     def delete_tenant(self, req, tenant_id):
-        rval = config.SERVICE.delete_tenant(utils.get_auth_token(req),
+        rval = IdentityService.delete_tenant(utils.get_auth_token(req),
             tenant_id)
         return utils.send_result(204, req, rval)
diff --git a/keystone/controllers/token.py b/keystone/controllers/token.py
index bc31857e..0063b759 100644
--- a/keystone/controllers/token.py
+++ b/keystone/controllers/token.py
@@ -28,7 +28,7 @@ from keystone import utils
 from keystone.common import wsgi
 from keystone.logic.types import auth
 from keystone.logic.types import fault
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from . import get_marker_limit_and_url
 
 
@@ -43,12 +43,12 @@ class TokenController(wsgi.Controller):
         try:
             auth_with_credentials = utils.get_normalized_request_content(
                 auth.AuthWithPasswordCredentials, req)
-            result = config.SERVICE.authenticate(auth_with_credentials)
+            result = IdentityService.authenticate(auth_with_credentials)
         except fault.BadRequestFault as e1:
             try:
                 unscoped = utils.get_normalized_request_content(
                     auth.AuthWithUnscopedToken, req)
-                result = config.SERVICE.authenticate_with_unscoped_token(
+                result = IdentityService.authenticate_with_unscoped_token(
                     unscoped)
             except fault.BadRequestFault as e2:
                 if e1.msg == e2.msg:
@@ -62,12 +62,12 @@ class TokenController(wsgi.Controller):
     def authenticate_ec2(self, req):
         creds = utils.get_normalized_request_content(auth.Ec2Credentials, req)
         return utils.send_result(200, req,
-            config.SERVICE.authenticate_ec2(creds))
+            IdentityService.authenticate_ec2(creds))
 
     def _validate_token(self, req, token_id):
         """Validates the token, and that it belongs to the specified tenant"""
         belongs_to = req.GET.get('belongsTo')
-        return config.SERVICE.validate_token(
+        return IdentityService.validate_token(
             utils.get_auth_token(req), token_id, belongs_to)
 
     @utils.wrap_error
@@ -84,12 +84,12 @@ class TokenController(wsgi.Controller):
     @utils.wrap_error
     def delete_token(self, req, token_id):
         return utils.send_result(204, req,
-            config.SERVICE.revoke_token(utils.get_auth_token(req), token_id))
+            IdentityService.revoke_token(utils.get_auth_token(req), token_id))
 
     @utils.wrap_error
     def endpoints(self, req, token_id):
         marker, limit, url = get_marker_limit_and_url(req)
         return utils.send_result(200, req,
-            config.SERVICE.get_endpoints_for_token(
+            IdentityService.get_endpoints_for_token(
                 utils.get_auth_token(req),
                 token_id, marker, limit, url))
diff --git a/keystone/controllers/user.py b/keystone/controllers/user.py
index fda0e219..bec351d6 100644
--- a/keystone/controllers/user.py
+++ b/keystone/controllers/user.py
@@ -1,6 +1,6 @@
 from keystone import utils
 from keystone.common import wsgi
-import keystone.config as config
+from keystone.logic.service import IdentityService
 from keystone.logic.types.user import User, User_Update
 from . import get_marker_limit_and_url
 
@@ -14,58 +14,58 @@ class UserController(wsgi.Controller):
     @utils.wrap_error
     def create_user(self, req):
         u = utils.get_normalized_request_content(User, req)
-        return utils.send_result(201, req, config.SERVICE.create_user(
+        return utils.send_result(201, req, IdentityService.create_user(
             utils.get_auth_token(req), u))
 
     @utils.wrap_error
     def get_users(self, req):
         user_name = req.GET["name"] if "name" in req.GET else None
         if user_name:
-            tenant = config.SERVICE.get_user_by_name(
+            tenant = IdentityService.get_user_by_name(
                 utils.get_auth_token(req),
                 user_name)
             return utils.send_result(200, req, tenant)
         else:
             marker, limit, url = get_marker_limit_and_url(req)
-            users = config.SERVICE.get_users(utils.get_auth_token(req), marker,
-                limit, url)
+            users = IdentityService.get_users(utils.get_auth_token(req),
+                marker, limit, url)
             return utils.send_result(200, req, users)
 
     @utils.wrap_error
     def get_user(self, req, user_id):
-        user = config.SERVICE.get_user(utils.get_auth_token(req), user_id)
+        user = IdentityService.get_user(utils.get_auth_token(req), user_id)
         return utils.send_result(200, req, user)
 
     @utils.wrap_error
     def update_user(self, req, user_id):
         user = utils.get_normalized_request_content(User_Update, req)
-        rval = config.SERVICE.update_user(utils.get_auth_token(req), user_id,
+        rval = IdentityService.update_user(utils.get_auth_token(req), user_id,
             user)
         return utils.send_result(200, req, rval)
 
     @utils.wrap_error
     def delete_user(self, req, user_id):
-        rval = config.SERVICE.delete_user(utils.get_auth_token(req), user_id)
+        rval = IdentityService.delete_user(utils.get_auth_token(req), user_id)
         return utils.send_result(204, req, rval)
 
     @utils.wrap_error
     def set_user_password(self, req, user_id):
         user = utils.get_normalized_request_content(User_Update, req)
-        rval = config.SERVICE.set_user_password(utils.get_auth_token(req),
+        rval = IdentityService.set_user_password(utils.get_auth_token(req),
             user_id, user)
         return utils.send_result(200, req, rval)
 
     @utils.wrap_error
     def set_user_enabled(self, req, user_id):
         user = utils.get_normalized_request_content(User_Update, req)
-        rval = config.SERVICE.enable_disable_user(utils.get_auth_token(req),
+        rval = IdentityService.enable_disable_user(utils.get_auth_token(req),
             user_id, user)
         return utils.send_result(200, req, rval)
 
     @utils.wrap_error
     def update_user_tenant(self, req, user_id):
         user = utils.get_normalized_request_content(User_Update, req)
-        rval = config.SERVICE.set_user_tenant(utils.get_auth_token(req),
+        rval = IdentityService.set_user_tenant(utils.get_auth_token(req),
             user_id, user)
         return utils.send_result(200, req, rval)
 
@@ -73,6 +73,6 @@ class UserController(wsgi.Controller):
     def get_tenant_users(self, req, tenant_id):
         marker, limit, url = get_marker_limit_and_url(req)
         role_id = req.GET["roleId"] if "roleId" in req.GET else None
-        users = config.SERVICE.get_tenant_users(utils.get_auth_token(req),
+        users = IdentityService.get_tenant_users(utils.get_auth_token(req),
             tenant_id, role_id, marker, limit, url)
         return utils.send_result(200, req, users)
diff --git a/keystone/logic/service.py b/keystone/logic/service.py
index 7350b05a..db2e81c7 100755
--- a/keystone/logic/service.py
+++ b/keystone/logic/service.py
@@ -30,6 +30,7 @@ from keystone.logic.types.user import User, User_Update, Users
 from keystone.logic.types.endpoint import Endpoint, Endpoints, \
     EndpointTemplate, EndpointTemplates
 from keystone.logic.types.credential import Credentials, PasswordCredentials
+from keystone.common import wsgi
 from keystone import utils