Fix KeystoneMiddleware memcachepool abstraction

Keystonemiddleware's abstraction for the memcache pool was broken
when converting to use a queue.Queue. The logic that placed the
connection back into the pool was moved to .acquire and the reserve
method was not using acquire.

Conflicts:
    keystonemiddleware/auth_token/_cache.py
    keystonemiddleware/tests/unit/auth_token/test_cache.py

Change-Id: I0eda5981cbb661f63790258cf8e70c7340615159
Closes-Bug: #1782404
(cherry picked from commit dea1e94d6c)

keystonemiddleware/auth_token/_cache.py

@@ -97,7 +97,10 @@ class _MemcacheClientPool(object):
 
     @contextlib.contextmanager
     def reserve(self):
-        with self._pool.get() as client:
+        # NOTE(morgan): We must use "acquire" if we want all the added context
+        # manager logic that places the connection back into the pool at the
+        # end of it's use.
+        with self._pool.acquire() as client:
             yield client
 
 

keystonemiddleware/tests/unit/auth_token/test_cache.py

@@ -12,8 +12,10 @@
 
 import uuid
 
+import fixtures
 import six
 
+from keystonemiddleware.auth_token import _cache
 from keystonemiddleware.auth_token import _exceptions as exc
 from keystonemiddleware.tests.unit.auth_token import base
 from keystonemiddleware.tests.unit import utils
@@ -150,3 +152,24 @@ class TestLiveMemcache(base.BaseAuthTokenTestCase):
         token_cache.initialize({})
         token_cache.set(token, data)
         self.assertEqual(token_cache.get(token), data)
+
+
+class TestMemcachePoolAbstraction(utils.TestCase):
+    def setUp(self):
+        super(TestMemcachePoolAbstraction, self).setUp()
+        self.useFixture(fixtures.MockPatch(
+            'oslo_cache._memcache_pool._MemcacheClient'))
+
+    def test_abstraction_layer_reserve_places_connection_back_in_pool(self):
+        cache_pool = _cache._MemcacheClientPool(
+            memcache_servers=[], arguments={}, maxsize=1, unused_timeout=10)
+        conn = None
+        with cache_pool.reserve() as client:
+            self.assertEqual(cache_pool._pool._acquired, 1)
+            conn = client
+
+        self.assertEqual(cache_pool._pool._acquired, 0)
+        with cache_pool.reserve() as client:
+            # Make sure the connection we got before is in-fact the one we
+            # get again.
+            self.assertEqual(conn, client)