From 9d2d572eaa0c4fbc48588b103a176a132e0476d9 Mon Sep 17 00:00:00 2001
From: Boris Pavlovic <boris@pavlovic.me>
Date: Wed, 26 Mar 2014 15:22:03 +0400
Subject: [PATCH] Fix session handling in novaclient
Prior to this patch, novaclient was handling sessions in an inconsistent
manner.
Every time we created a client instance, it would use a global
connection pool, which made it difficult to use in a process that is
meant to be forked.
Obviously sessions like the ones provided by the requests library that
will automatically cause connections to be kept alive should not be
implicit. This patch moves the novaclient back to the age of a single
session-less request call by default, but also adds two more
resource-reuse friendly options that a user needs to be explicit about.
The first one is that both v1_1 and v3 clients can now be used as
context managers,. where the session will be kept open (and thus the
connection kept-alive) for the duration of the with block. This is far
more ideal for a web worker use-case as the session can be made
request-long.
The second one is the per-instance session. This is very similar to what
we had up until now, except it is not a global object so forking is
possible as long as each child instantiates it's own client. The session
once created will be kept open for the duration of the client object
lifetime.
Please note: client instances are not thread safe. As can be seen from
above forking example - if you wish to use threading/multiprocessing,
you *must not* share client instances.
DocImpact
Related-bug: #1247056
Closes-Bug: #1297796
Co-authored-by: Nikola Dipanov <ndipanov@redhat.com>
Change-Id: Id59e48f61bb3f3c6223302355c849e1e99673410
Conflicts:
novaclient/client.py
novaclient/tests/test_client.py
novaclient/tests/test_http.py
novaclient/v1_1/client.py
novaclient/v3/client.py
---
novaclient/client.py | 74 +++++++++++++++--------
novaclient/tests/test_auth_plugins.py | 8 +--
novaclient/tests/test_client.py | 110 +++++++++++++++++++++++++++++++++-
novaclient/tests/test_http.py | 8 +--
novaclient/tests/v1_1/test_auth.py | 12 ++--
novaclient/v1_1/client.py | 27 ++++++++-
novaclient/v3/client.py | 27 ++++++++-
7 files changed, 221 insertions(+), 45 deletions(-)
diff --git a/novaclient/client.py b/novaclient/client.py
index 0b9aeee..7f5032b 100644
--- a/novaclient/client.py
+++ b/novaclient/client.py
@@ -39,17 +39,19 @@ from novaclient import service_catalog
from novaclient import utils
-_ADAPTERS = {}
+class _ClientConnectionPool(object):
+ def __init__(self):
+ self._adapters = {}
-def _adapter_pool(url):
- """
- Store and reuse HTTP adapters per Service URL.
- """
- if url not in _ADAPTERS:
- _ADAPTERS[url] = adapters.HTTPAdapter()
+ def get(self, url):
+ """
+ Store and reuse HTTP adapters per Service URL.
+ """
+ if url not in self._adapters:
+ self._adapters[url] = adapters.HTTPAdapter()
- return _ADAPTERS[url]
+ return self._adapters[url]
class HTTPClient(object):
@@ -64,12 +66,16 @@ class HTTPClient(object):
os_cache=False, no_cache=True,
http_log_debug=False, auth_system='keystone',
auth_plugin=None, auth_token=None,
- cacert=None, tenant_id=None):
+ cacert=None, tenant_id=None,
+ connection_pool=False):
self.user = user
self.password = password
self.projectid = projectid
self.tenant_id = tenant_id
+ self._connection_pool = (_ClientConnectionPool()
+ if connection_pool else None)
+
# This will be called by #_get_password if self.password is None.
# EG if a password can only be obtained by prompting the user, but a
# token is available, you don't want to prompt until the token has
@@ -118,8 +124,8 @@ class HTTPClient(object):
self.auth_system = auth_system
self.auth_plugin = auth_plugin
+ self._session = None
self._current_url = None
- self._http = None
self._logger = logging.getLogger(__name__)
if self.http_log_debug and not self._logger.handlers:
@@ -180,19 +186,33 @@ class HTTPClient(object):
'headers': resp.headers,
'text': resp.text})
- def http(self, url):
- magic_tuple = parse.urlsplit(url)
- scheme, netloc, path, query, frag = magic_tuple
- service_url = '%s://%s' % (scheme, netloc)
- if self._current_url != service_url:
- # Invalidate Session object in case the url is somehow changed
- if self._http:
- self._http.close()
- self._current_url = service_url
- self._logger.debug("New session created for: (%s)" % service_url)
- self._http = requests.Session()
- self._http.mount(service_url, _adapter_pool(service_url))
- return self._http
+ def open_session(self):
+ if not self._connection_pool:
+ self._session = requests.Session()
+
+ def close_session(self):
+ if self._session and not self._connection_pool:
+ self._session.close()
+ self._session = None
+
+ def _get_session(self, url):
+ if self._connection_pool:
+ magic_tuple = parse.urlsplit(url)
+ scheme, netloc, path, query, frag = magic_tuple
+ service_url = '%s://%s' % (scheme, netloc)
+ if self._current_url != service_url:
+ # Invalidate Session object in case the url is somehow changed
+ if self._session:
+ self._session.close()
+ self._current_url = service_url
+ self._logger.debug(
+ "New session created for: (%s)" % service_url)
+ self._session = requests.Session()
+ self._session.mount(service_url,
+ self._connection_pool.get(service_url))
+ return self._session
+ elif self._session:
+ return self._session
def request(self, url, method, **kwargs):
kwargs.setdefault('headers', kwargs.get('headers', {}))
@@ -207,7 +227,13 @@ class HTTPClient(object):
kwargs['verify'] = self.verify_cert
self.http_log_req(method, url, kwargs)
- resp = self.http(url).request(
+
+ request_func = requests.request
+ session = self._get_session(url)
+ if session:
+ request_func = session.request
+
+ resp = request_func(
method,
url,
**kwargs)
diff --git a/novaclient/tests/test_auth_plugins.py b/novaclient/tests/test_auth_plugins.py
index a084594..1761b98 100644
--- a/novaclient/tests/test_auth_plugins.py
+++ b/novaclient/tests/test_auth_plugins.py
@@ -92,7 +92,7 @@ class DeprecatedAuthPluginTest(utils.TestCase):
@mock.patch.object(pkg_resources, "iter_entry_points",
mock_iter_entry_points)
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
plugin = auth_plugin.DeprecatedAuthPlugin("fake")
cs = client.Client("username", "password", "project_id",
@@ -121,7 +121,7 @@ class DeprecatedAuthPluginTest(utils.TestCase):
@mock.patch.object(pkg_resources, "iter_entry_points",
mock_iter_entry_points)
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
auth_plugin.discover_auth_systems()
plugin = auth_plugin.DeprecatedAuthPlugin("notexists")
@@ -164,7 +164,7 @@ class DeprecatedAuthPluginTest(utils.TestCase):
@mock.patch.object(pkg_resources, "iter_entry_points",
mock_iter_entry_points)
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
plugin = auth_plugin.DeprecatedAuthPlugin("fakewithauthurl")
cs = client.Client("username", "password", "project_id",
@@ -197,7 +197,7 @@ class DeprecatedAuthPluginTest(utils.TestCase):
class AuthPluginTest(utils.TestCase):
- @mock.patch.object(requests.Session, "request")
+ @mock.patch.object(requests, "request")
@mock.patch.object(pkg_resources, "iter_entry_points")
def test_auth_system_success(self, mock_iter_entry_points, mock_request):
"""Test that we can authenticate using the auth system."""
diff --git a/novaclient/tests/test_client.py b/novaclient/tests/test_client.py
index d586702..96901b9 100644
--- a/novaclient/tests/test_client.py
+++ b/novaclient/tests/test_client.py
@@ -27,6 +27,16 @@ import novaclient.v3.client
import json
+class ClientConnectionPoolTest(utils.TestCase):
+
+ @mock.patch("novaclient.client.adapters.HTTPAdapter")
+ def test_get(self, mock_http_adapter):
+ mock_http_adapter.side_effect = lambda: mock.Mock()
+ pool = novaclient.client._ClientConnectionPool()
+ self.assertEqual(pool.get("abc"), pool.get("abc"))
+ self.assertNotEqual(pool.get("abc"), pool.get("def"))
+
+
class ClientTest(utils.TestCase):
def test_client_with_timeout(self):
@@ -43,9 +53,9 @@ class ClientTest(utils.TestCase):
'x-server-management-url': 'blah.com',
'x-auth-token': 'blah',
}
- with mock.patch('requests.Session.request', mock_request):
+ with mock.patch('requests.request', mock_request):
instance.authenticate()
- requests.Session.request.assert_called_with(mock.ANY, mock.ANY,
+ requests.request.assert_called_with(mock.ANY, mock.ANY,
timeout=2,
headers=mock.ANY,
verify=mock.ANY)
@@ -61,7 +71,7 @@ class ClientTest(utils.TestCase):
instance.version = 'v2.0'
mock_request = mock.Mock()
mock_request.side_effect = novaclient.exceptions.Unauthorized(401)
- with mock.patch('requests.Session.request', mock_request):
+ with mock.patch('requests.request', mock_request):
try:
instance.get('/servers/detail')
except Exception:
@@ -197,6 +207,26 @@ class ClientTest(utils.TestCase):
cs.authenticate()
self.assertTrue(mock_authenticate.called)
+ @mock.patch('novaclient.client.HTTPClient')
+ def test_contextmanager_v1_1(self, mock_http_client):
+ fake_client = mock.Mock()
+ mock_http_client.return_value = fake_client
+ with novaclient.v1_1.client.Client("user", "password", "project_id",
+ auth_url="foo/v2") as client:
+ pass
+ self.assertTrue(fake_client.open_session.called)
+ self.assertTrue(fake_client.close_session.called)
+
+ @mock.patch('novaclient.client.HTTPClient')
+ def test_contextmanager_v3(self, mock_http_client):
+ fake_client = mock.Mock()
+ mock_http_client.return_value = fake_client
+ with novaclient.v3.client.Client("user", "password", "project_id",
+ auth_url="foo/v2") as client:
+ pass
+ self.assertTrue(fake_client.open_session.called)
+ self.assertTrue(fake_client.close_session.called)
+
def test_get_password_simple(self):
cs = novaclient.client.HTTPClient("user", "password", "", "")
cs.password_func = mock.Mock()
@@ -216,3 +246,77 @@ class ClientTest(utils.TestCase):
cs.password_func = mock.Mock()
self.assertEqual(cs._get_password(), "password")
self.assertFalse(cs.password_func.called)
+
+ def test_auth_url_rstrip_slash(self):
+ cs = novaclient.client.HTTPClient("user", "password", "project_id",
+ auth_url="foo/v2/")
+ self.assertEqual(cs.auth_url, "foo/v2")
+
+ def test_token_and_bypass_url(self):
+ cs = novaclient.client.HTTPClient(None, None, None,
+ auth_token="12345",
+ bypass_url="compute/v100/")
+ self.assertIsNone(cs.auth_url)
+ self.assertEqual(cs.auth_token, "12345")
+ self.assertEqual(cs.bypass_url, "compute/v100")
+ self.assertEqual(cs.management_url, "compute/v100")
+
+ @mock.patch("novaclient.client.requests.Session")
+ def test_session(self, mock_session):
+ fake_session = mock.Mock()
+ mock_session.return_value = fake_session
+ cs = novaclient.client.HTTPClient("user", None, "", "")
+ cs.open_session()
+ self.assertEqual(cs._session, fake_session)
+ cs.close_session()
+ self.assertIsNone(cs._session)
+
+ def test_session_connection_pool(self):
+ cs = novaclient.client.HTTPClient("user", None, "",
+ "", connection_pool=True)
+ cs.open_session()
+ self.assertIsNone(cs._session)
+ cs.close_session()
+ self.assertIsNone(cs._session)
+
+ def test_get_session(self):
+ cs = novaclient.client.HTTPClient("user", None, "", "")
+ self.assertIsNone(cs._get_session("http://nooooooooo.com"))
+
+ @mock.patch("novaclient.client.requests.Session")
+ def test_get_session_open_session(self, mock_session):
+ fake_session = mock.Mock()
+ mock_session.return_value = fake_session
+ cs = novaclient.client.HTTPClient("user", None, "", "")
+ cs.open_session()
+ self.assertEqual(fake_session, cs._get_session("http://example.com"))
+
+ @mock.patch("novaclient.client.requests.Session")
+ @mock.patch("novaclient.client._ClientConnectionPool")
+ def test_get_session_connection_pool(self, mock_pool, mock_session):
+ service_url = "http://example.com"
+
+ pool = mock.MagicMock()
+ pool.get.return_value = "http_adapter"
+ mock_pool.return_value = pool
+ cs = novaclient.client.HTTPClient("user", None, "",
+ "", connection_pool=True)
+ cs._current_url = "http://another.com"
+
+ session = cs._get_session(service_url)
+ self.assertEqual(session, mock_session.return_value)
+ pool.get.assert_called_once_with(service_url)
+ mock_session().mount.assert_called_once_with(service_url,
+ 'http_adapter')
+
+ def test_init_without_connection_pool(self):
+ cs = novaclient.client.HTTPClient("user", None, "", "")
+ self.assertIsNone(cs._connection_pool)
+
+ @mock.patch("novaclient.client._ClientConnectionPool")
+ def test_init_with_proper_connection_pool(self, mock_pool):
+ fake_pool = mock.Mock()
+ mock_pool.return_value = fake_pool
+ cs = novaclient.client.HTTPClient("user", None, "",
+ connection_pool=True)
+ self.assertEqual(cs._connection_pool, fake_pool)
diff --git a/novaclient/tests/test_http.py b/novaclient/tests/test_http.py
index e2fc4fa..aaa3a46 100644
--- a/novaclient/tests/test_http.py
+++ b/novaclient/tests/test_http.py
@@ -56,7 +56,7 @@ class ClientTest(utils.TestCase):
def test_get(self):
cl = get_authed_client()
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
@mock.patch('time.time', mock.Mock(return_value=1234))
def test_get_call():
resp, body = cl.get("/hi")
@@ -78,7 +78,7 @@ class ClientTest(utils.TestCase):
def test_post(self):
cl = get_authed_client()
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_post_call():
cl.post("/hi", body=[1, 2, 3])
headers = {
@@ -110,7 +110,7 @@ class ClientTest(utils.TestCase):
def test_connection_refused(self):
cl = get_client()
- @mock.patch.object(requests.Session, "request", refused_mock_request)
+ @mock.patch.object(requests, "request", refused_mock_request)
def test_refused_call():
self.assertRaises(exceptions.ConnectionRefused, cl.get, "/hi")
@@ -119,7 +119,7 @@ class ClientTest(utils.TestCase):
def test_bad_request(self):
cl = get_client()
- @mock.patch.object(requests.Session, "request", bad_req_mock_request)
+ @mock.patch.object(requests, "request", bad_req_mock_request)
def test_refused_call():
self.assertRaises(exceptions.BadRequest, cl.get, "/hi")
diff --git a/novaclient/tests/v1_1/test_auth.py b/novaclient/tests/v1_1/test_auth.py
index 7344bc7..7877145 100644
--- a/novaclient/tests/v1_1/test_auth.py
+++ b/novaclient/tests/v1_1/test_auth.py
@@ -57,7 +57,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
mock_request = mock.Mock(return_value=(auth_response))
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
cs.client.authenticate()
headers = {
@@ -160,7 +160,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
mock_request = mock.Mock(side_effect=side_effect)
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
cs.client.authenticate()
headers = {
@@ -248,7 +248,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
mock_request = mock.Mock(side_effect=side_effect)
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
cs.client.authenticate()
headers = {
@@ -373,7 +373,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
mock_request = mock.Mock(return_value=(auth_response))
- with mock.patch.object(requests.Session, "request", mock_request):
+ with mock.patch.object(requests, "request", mock_request):
cs.client.authenticate()
headers = {
'User-Agent': cs.client.USER_AGENT,
@@ -432,7 +432,7 @@ class AuthenticationTests(utils.TestCase):
})
mock_request = mock.Mock(return_value=(auth_response))
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
cs.client.authenticate()
headers = {
@@ -460,7 +460,7 @@ class AuthenticationTests(utils.TestCase):
auth_response = utils.TestResponse({'status_code': 401})
mock_request = mock.Mock(return_value=(auth_response))
- @mock.patch.object(requests.Session, "request", mock_request)
+ @mock.patch.object(requests, "request", mock_request)
def test_auth_call():
self.assertRaises(exceptions.Unauthorized, cs.client.authenticate)
diff --git a/novaclient/v1_1/client.py b/novaclient/v1_1/client.py
index efeb5c9..ce4aea1 100644
--- a/novaclient/v1_1/client.py
+++ b/novaclient/v1_1/client.py
@@ -61,6 +61,20 @@ class Client(object):
>>> client.flavors.list()
...
+ It is also possible to use an instance as a context manager in which
+ case there will be a session kept alive for the duration of the with
+ statement::
+
+ >>> with Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL) as client:
+ ... client.servers.list()
+ ... client.flavors.list()
+ ...
+
+ It is also possible to have a permanent (process-long) connection pool,
+ by passing a connection_pool=True::
+
+ >>> client = Client(USERNAME, PASSWORD, PROJECT_ID,
+ ... AUTH_URL, connection_pool=True)
"""
# FIXME(jesse): project_id isn't required to authenticate
@@ -73,7 +87,8 @@ class Client(object):
bypass_url=None, os_cache=False, no_cache=True,
http_log_debug=False, auth_system='keystone',
auth_plugin=None, auth_token=None,
- cacert=None, tenant_id=None):
+ cacert=None, tenant_id=None,
+ connection_pool=False):
# FIXME(comstud): Rename the api_key argument above when we
# know it's not being used as keyword argument
password = api_key
@@ -145,7 +160,15 @@ class Client(object):
bypass_url=bypass_url,
os_cache=self.os_cache,
http_log_debug=http_log_debug,
- cacert=cacert)
+ cacert=cacert,
+ connection_pool=connection_pool)
+
+ def __enter__(self):
+ self.client.open_session()
+ return self
+
+ def __exit__(self, t, v, tb):
+ self.client.close_session()
def set_management_url(self, url):
self.client.set_management_url(url)
diff --git a/novaclient/v3/client.py b/novaclient/v3/client.py
index f26fdcf..214ba57 100644
--- a/novaclient/v3/client.py
+++ b/novaclient/v3/client.py
@@ -47,6 +47,20 @@ class Client(object):
>>> client.flavors.list()
...
+ It is also possible to use an instance as a context manager in which
+ case there will be a session kept alive for the duration of the with
+ statement::
+
+ >>> with Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL) as client:
+ ... client.servers.list()
+ ... client.flavors.list()
+ ...
+
+ It is also possible to have a permanent (process-long) connection pool,
+ by passing a connection_pool=True::
+
+ >>> client = Client(USERNAME, PASSWORD, PROJECT_ID,
+ ... AUTH_URL, connection_pool=True)
"""
# FIXME(jesse): project_id isn't required to authenticate
@@ -59,7 +73,8 @@ class Client(object):
bypass_url=None, os_cache=False, no_cache=True,
http_log_debug=False, auth_system='keystone',
auth_plugin=None, auth_token=None,
- cacert=None, tenant_id=None):
+ cacert=None, tenant_id=None,
+ connection_pool=False):
self.projectid = project_id
self.tenant_id = tenant_id
self.os_cache = os_cache or not no_cache
@@ -110,7 +125,15 @@ class Client(object):
bypass_url=bypass_url,
os_cache=os_cache,
http_log_debug=http_log_debug,
- cacert=cacert)
+ cacert=cacert,
+ connection_pool=connection_pool)
+
+ def __enter__(self):
+ self.client.open_session()
+ return self
+
+ def __exit__(self, t, v, tb):
+ self.client.close_session()
def set_management_url(self, url):
self.client.set_management_url(url)