openstack
/
keystonemiddleware
Code Issues Proposed changes

Handle memcache pool arguments collectively 

Tracing the usage of memcache pool arguments goes through 3 different
functions and involves slightly tweaking the parameter names each time.

This was making it impossible to reason with so collapse down the
memcache arguments into a dictionary that is passed around.

Change-Id: I8bd5cb50183795d9b8fd953dabd935f15f03a385
This commit is contained in:
Jamie Lennox 2015-08-13 12:28:51 +10:00
parent 2fe6f851f4
commit e9ad5188de
3 changed files with 26 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
keystonemiddleware/auth_token/__init__.py
View File

@ -1050,15 +1050,11 @@ class AuthProtocol(_BaseAuthProtocol):
env_cache_name=self._conf_get('cache'),
memcached_servers=self._conf_get('memcached_servers'),
use_advanced_pool=self._conf_get('memcache_use_advanced_pool'),
memcache_pool_dead_retry=self._conf_get(
'memcache_pool_dead_retry'),
memcache_pool_maxsize=self._conf_get('memcache_pool_maxsize'),
memcache_pool_unused_timeout=self._conf_get(
'memcache_pool_unused_timeout'),
memcache_pool_conn_get_timeout=self._conf_get(
'memcache_pool_conn_get_timeout'),
memcache_pool_socket_timeout=self._conf_get(
'memcache_pool_socket_timeout'),
dead_retry=self._conf_get('memcache_pool_dead_retry'),
maxsize=self._conf_get('memcache_pool_maxsize'),
unused_timeout=self._conf_get('memcache_pool_unused_timeout'),
conn_get_timeout=self._conf_get('memcache_pool_conn_get_timeout'),
socket_timeout=self._conf_get('memcache_pool_socket_timeout'),
)
if security_strategy:

61
keystonemiddleware/auth_token/_cache.py
View File

@ -67,25 +67,14 @@ class _CachePool(list):
class _MemcacheClientPool(object):
"""An advanced memcached client pool that is eventlet safe."""
def __init__(self, memcache_servers, memcache_dead_retry=None,
memcache_pool_maxsize=None, memcache_pool_unused_timeout=None,
memcache_pool_conn_get_timeout=None,
memcache_pool_socket_timeout=None):
def __init__(self, memcache_servers, **kwargs):
# NOTE(morganfainberg): import here to avoid hard dependency on
# python-memcached library.
global _memcache_pool
from keystonemiddleware.auth_token import _memcache_pool
self._pool = _memcache_pool.MemcacheClientPool(
memcache_servers,
arguments={
'dead_retry': memcache_dead_retry,
'socket_timeout': memcache_pool_socket_timeout,
},
maxsize=memcache_pool_maxsize,
unused_timeout=memcache_pool_unused_timeout,
conn_get_timeout=memcache_pool_conn_get_timeout,
)
self._pool = _memcache_pool.MemcacheClientPool(memcache_servers,
**kwargs)
@contextlib.contextmanager
def reserve(self):
@ -114,54 +103,32 @@ class TokenCache(object):
def __init__(self, log, cache_time=None,
env_cache_name=None, memcached_servers=None,
use_advanced_pool=False, memcache_pool_dead_retry=None,
memcache_pool_maxsize=None, memcache_pool_unused_timeout=None,
memcache_pool_conn_get_timeout=None,
memcache_pool_socket_timeout=None):
use_advanced_pool=False, **kwargs):
self._LOG = log
self._cache_time = cache_time
self._env_cache_name = env_cache_name
self._memcached_servers = memcached_servers
self._use_advanced_pool = use_advanced_pool
self._memcache_pool_dead_retry = memcache_pool_dead_retry,
self._memcache_pool_maxsize = memcache_pool_maxsize,
self._memcache_pool_unused_timeout = memcache_pool_unused_timeout
self._memcache_pool_conn_get_timeout = memcache_pool_conn_get_timeout
self._memcache_pool_socket_timeout = memcache_pool_socket_timeout
self._memcache_pool_options = kwargs
self._cache_pool = None
self._initialized = False
def _get_cache_pool(self, cache, memcache_servers, use_advanced_pool=False,
memcache_dead_retry=None, memcache_pool_maxsize=None,
memcache_pool_unused_timeout=None,
memcache_pool_conn_get_timeout=None,
memcache_pool_socket_timeout=None):
if use_advanced_pool is True and memcache_servers and cache is None:
return _MemcacheClientPool(
memcache_servers,
memcache_dead_retry=memcache_dead_retry,
memcache_pool_maxsize=memcache_pool_maxsize,
memcache_pool_unused_timeout=memcache_pool_unused_timeout,
memcache_pool_conn_get_timeout=memcache_pool_conn_get_timeout,
memcache_pool_socket_timeout=memcache_pool_socket_timeout)
def _get_cache_pool(self, cache):
if (self._use_advanced_pool is True and
self._memcached_servers and
cache is None):
return _MemcacheClientPool(self._memcached_servers,
**self._memcache_pool_options)
else:
return _CachePool(cache, memcache_servers)
return _CachePool(cache, self._memcached_servers)
def initialize(self, env):
if self._initialized:
return
self._cache_pool = self._get_cache_pool(
env.get(self._env_cache_name),
self._memcached_servers,
use_advanced_pool=self._use_advanced_pool,
memcache_dead_retry=self._memcache_pool_dead_retry,
memcache_pool_maxsize=self._memcache_pool_maxsize,
memcache_pool_unused_timeout=self._memcache_pool_unused_timeout,
memcache_pool_conn_get_timeout=self._memcache_pool_conn_get_timeout
)
self._cache_pool = self._get_cache_pool(env.get(self._env_cache_name))
self._initialized = True
def store(self, token_id, data):

10
keystonemiddleware/auth_token/_memcache_pool.py
View File

@ -114,10 +114,12 @@ class ConnectionPool(queue.Queue):
class MemcacheClientPool(ConnectionPool):
def __init__(self, urls, arguments, **kwargs):
def __init__(self, urls, dead_retry=None, socket_timeout=None, **kwargs):
ConnectionPool.__init__(self, **kwargs)
self._urls = urls
self._arguments = arguments
self._dead_retry = dead_retry
self._socket_timeout = socket_timeout
# NOTE(morganfainberg): The host objects expect an int for the
# deaduntil value. Initialize this at 0 for each host with 0 indicating
# the host is not dead.
@ -138,7 +140,9 @@ class MemcacheClientPool(ConnectionPool):
self._memcache_client_class = MemcacheClient
def _create_connection(self):
return self._memcache_client_class(self._urls, **self._arguments)
return self._memcache_client_class(self._urls,
dead_retry=self._dead_retry,
socket_timeout=self._socket_timeout)
def _destroy_connection(self, conn):
conn.disconnect_all()