From 41083a5ddae0a1dc1c897e17f7cc8b582a86a614 Mon Sep 17 00:00:00 2001 From: Jamie Lennox Date: Tue, 5 Jul 2016 10:44:56 +1000 Subject: [PATCH] Remove oslo-incubator Oslo-incubator has been deprecated. The only thing that we use from it is the memorycache which is hopefully going away soon. Copy this memorycache code into the _cache module so that we can refactor it as necessary without worrying about oslo-incubator. Involves some minor cleanups for pep8 fixes and making functions private. Change-Id: I7a19d4ded8b538b6ea02e4a08068c863705194a3 --- keystonemiddleware/auth_token/_cache.py | 57 ++++++++++- keystonemiddleware/openstack/__init__.py | 0 .../openstack/common/__init__.py | 0 .../openstack/common/memorycache.py | 97 ------------------- .../auth_token/test_auth_token_middleware.py | 6 +- openstack-common.conf | 7 -- tox.ini | 2 +- 7 files changed, 59 insertions(+), 110 deletions(-) delete mode 100644 keystonemiddleware/openstack/__init__.py delete mode 100644 keystonemiddleware/openstack/common/__init__.py delete mode 100644 keystonemiddleware/openstack/common/memorycache.py delete mode 100644 openstack-common.conf diff --git a/keystonemiddleware/auth_token/_cache.py b/keystonemiddleware/auth_token/_cache.py index a225dbfb..5db5c64f 100644 --- a/keystonemiddleware/auth_token/_cache.py +++ b/keystonemiddleware/auth_token/_cache.py @@ -14,13 +14,13 @@ import contextlib import hashlib from oslo_serialization import jsonutils +from oslo_utils import timeutils import six from keystonemiddleware.auth_token import _exceptions as exc from keystonemiddleware.auth_token import _memcache_crypt as memcache_crypt from keystonemiddleware.auth_token import _memcache_pool as memcache_pool from keystonemiddleware.i18n import _, _LE, _LW -from keystonemiddleware.openstack.common import memorycache def _hash_key(key): @@ -74,7 +74,11 @@ class _CachePool(list): c = self.pop() except IndexError: # the pool is empty, so we need to create a new client - c = memorycache.get_client(self._memcached_servers) + if self._memcached_servers: + import memcache + c = memcache.Client(self._memcached_servers, debug=0) + else: + c = _FakeClient() try: yield c @@ -279,3 +283,52 @@ class SecureTokenCache(TokenCache): def _serialize(self, data, context): return memcache_crypt.protect_data(context, data) + + +class _FakeClient(object): + """Replicates a tiny subset of memcached client interface.""" + + def __init__(self, *args, **kwargs): + # Ignores the passed in args + self.cache = {} + + def get(self, key): + """Retrieve the value for a key or None. + + This expunges expired keys during each get. + """ + now = timeutils.utcnow_ts() + for k in list(self.cache): + (timeout, _value) = self.cache[k] + if timeout and now >= timeout: + del self.cache[k] + + return self.cache.get(key, (0, None))[1] + + def set(self, key, value, time=0, min_compress_len=0): + """Set the value for a key.""" + timeout = 0 + if time != 0: + timeout = timeutils.utcnow_ts() + time + self.cache[key] = (timeout, value) + return True + + def add(self, key, value, time=0, min_compress_len=0): + """Set the value for a key if it doesn't exist.""" + if self.get(key) is not None: + return False + return self.set(key, value, time, min_compress_len) + + def incr(self, key, delta=1): + """Increment the value for a key.""" + value = self.get(key) + if value is None: + return None + new_value = int(value) + delta + self.cache[key] = (self.cache[key][0], str(new_value)) + return new_value + + def delete(self, key, time=0): + """Delete the value associated with a key.""" + if key in self.cache: + del self.cache[key] diff --git a/keystonemiddleware/openstack/__init__.py b/keystonemiddleware/openstack/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/keystonemiddleware/openstack/common/__init__.py b/keystonemiddleware/openstack/common/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/keystonemiddleware/openstack/common/memorycache.py b/keystonemiddleware/openstack/common/memorycache.py deleted file mode 100644 index e72c26df..00000000 --- a/keystonemiddleware/openstack/common/memorycache.py +++ /dev/null @@ -1,97 +0,0 @@ -# Copyright 2010 United States Government as represented by the -# Administrator of the National Aeronautics and Space Administration. -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -"""Super simple fake memcache client.""" - -import copy - -from oslo_config import cfg -from oslo_utils import timeutils - -memcache_opts = [ - cfg.ListOpt('memcached_servers', - help='Memcached servers or None for in process cache.'), -] - -CONF = cfg.CONF -CONF.register_opts(memcache_opts) - - -def list_opts(): - """Entry point for oslo-config-generator.""" - return [(None, copy.deepcopy(memcache_opts))] - - -def get_client(memcached_servers=None): - client_cls = Client - - if not memcached_servers: - memcached_servers = CONF.memcached_servers - if memcached_servers: - import memcache - client_cls = memcache.Client - - return client_cls(memcached_servers, debug=0) - - -class Client(object): - """Replicates a tiny subset of memcached client interface.""" - - def __init__(self, *args, **kwargs): - """Ignores the passed in args.""" - self.cache = {} - - def get(self, key): - """Retrieves the value for a key or None. - - This expunges expired keys during each get. - """ - - now = timeutils.utcnow_ts() - for k in list(self.cache): - (timeout, _value) = self.cache[k] - if timeout and now >= timeout: - del self.cache[k] - - return self.cache.get(key, (0, None))[1] - - def set(self, key, value, time=0, min_compress_len=0): - """Sets the value for a key.""" - timeout = 0 - if time != 0: - timeout = timeutils.utcnow_ts() + time - self.cache[key] = (timeout, value) - return True - - def add(self, key, value, time=0, min_compress_len=0): - """Sets the value for a key if it doesn't exist.""" - if self.get(key) is not None: - return False - return self.set(key, value, time, min_compress_len) - - def incr(self, key, delta=1): - """Increments the value for a key.""" - value = self.get(key) - if value is None: - return None - new_value = int(value) + delta - self.cache[key] = (self.cache[key][0], str(new_value)) - return new_value - - def delete(self, key, time=0): - """Deletes the value associated with a key.""" - if key in self.cache: - del self.cache[key] diff --git a/keystonemiddleware/tests/unit/auth_token/test_auth_token_middleware.py b/keystonemiddleware/tests/unit/auth_token/test_auth_token_middleware.py index 6636c28e..0347ba30 100644 --- a/keystonemiddleware/tests/unit/auth_token/test_auth_token_middleware.py +++ b/keystonemiddleware/tests/unit/auth_token/test_auth_token_middleware.py @@ -41,9 +41,9 @@ import webob.dec from keystonemiddleware import auth_token from keystonemiddleware.auth_token import _base +from keystonemiddleware.auth_token import _cache from keystonemiddleware.auth_token import _exceptions as ksm_exceptions from keystonemiddleware.auth_token import _revocations -from keystonemiddleware.openstack.common import memorycache from keystonemiddleware.tests.unit.auth_token import base from keystonemiddleware.tests.unit import client_fixtures @@ -1048,7 +1048,7 @@ class CommonAuthTokenMiddlewareTest(object): def test_swift_memcache_set_expired(self): extra_conf = {'cache': 'swift.cache'} - extra_environ = {'swift.cache': memorycache.Client()} + extra_environ = {'swift.cache': _cache._FakeClient()} self.test_memcache_set_expired(extra_conf, extra_environ) def test_http_error_not_cached_token(self): @@ -1251,7 +1251,7 @@ class CommonAuthTokenMiddlewareTest(object): # The token cache has to be initialized with our cache instance. self.middleware._token_cache._env_cache_name = 'cache' - cache = memorycache.Client() + cache = _cache._FakeClient() self.middleware._token_cache.initialize(env={'cache': cache}) # Mock cache.set since then the test can verify call_count. diff --git a/openstack-common.conf b/openstack-common.conf deleted file mode 100644 index abdd7b30..00000000 --- a/openstack-common.conf +++ /dev/null @@ -1,7 +0,0 @@ -[DEFAULT] - -# The list of modules to copy from oslo-incubator -module=memorycache - -# The base module to hold the copy of openstack.common -base=keystonemiddleware diff --git a/tox.ini b/tox.ini index b89da994..56111b48 100644 --- a/tox.ini +++ b/tox.ini @@ -44,7 +44,7 @@ commands = oslo_debug_helper {posargs} # D203: 1 blank line required before class docstring (deprecated in pep257) ignore = D100,D101,D102,D103,D104,D203 show-source = True -exclude = .venv,.tox,dist,doc,*egg,build,*openstack/common* +exclude = .venv,.tox,dist,doc,*egg,build [testenv:docs] commands=