Merge "Send the correct user-agent to Keystone"

2 files changed, 111 insertions, 1 deletions

diff --git a/keystonemiddleware/auth_token/__init__.py b/keystonemiddleware/auth_token/__init__.py
index af7621d..204485b 100644
--- a/keystonemiddleware/auth_token/__init__.py
+++ b/keystonemiddleware/auth_token/__init__.py
@@ -211,6 +211,7 @@ from keystoneclient import exceptions
 from keystoneclient import session
 from oslo_config import cfg
 from oslo_serialization import jsonutils
+import pkg_resources
 import six
 import webob.dec
 
@@ -412,6 +413,10 @@ def _conf_values_type_convert(conf):
     return opts
 
 
+def _get_project_version(project):
+    return pkg_resources.get_distribution(project).version
+
+
 class _BaseAuthProtocol(object):
     """A base class for AuthProtocol token checking implementations.
 
@@ -942,6 +947,42 @@ class AuthProtocol(_BaseAuthProtocol):
 
         return plugin_class.load_from_options(**plugin_kwargs)
 
+    def _determine_project(self):
+        """Determine a project name from all available config sources.
+
+        The sources are checked in the following order::
+
+          1. The paste-deploy config for auth_token middleware
+          2. The keystone_authtoken in the project's config
+          3. The oslo.config CONF.project property
+
+        """
+        try:
+            return self._conf_get('project')
+        except cfg.NoSuchOptError:
+            try:
+                # CONF.project will exist only if the service uses
+                # oslo.config. It will only be set when the project
+                # calls CONF(...) and when not set oslo.config oddly
+                # raises a NoSuchOptError exception.
+                return CONF.project
+            except cfg.NoSuchOptError:
+                return ''
+
+    def _build_useragent_string(self):
+        project = self._determine_project()
+        if project:
+            project_version = _get_project_version(project)
+            project = '{project}/{project_version} '.format(
+                project=project,
+                project_version=project_version)
+
+        ua_template = ('{project}'
+                       'keystonemiddleware.auth_token/{ksm_version}')
+        return ua_template.format(
+            project=project,
+            ksm_version=_get_project_version('keystonemiddleware'))
+
     def _create_identity_server(self):
         # NOTE(jamielennox): Loading Session here should be exactly the
         # same as calling Session.load_from_conf_options(CONF, GROUP)
@@ -952,7 +993,8 @@ class AuthProtocol(_BaseAuthProtocol):
             key=self._conf_get('keyfile'),
             cacert=self._conf_get('cafile'),
             insecure=self._conf_get('insecure'),
-            timeout=self._conf_get('http_connect_timeout')
+            timeout=self._conf_get('http_connect_timeout'),
+            user_agent=self._build_useragent_string()
         ))
 
         auth_plugin = self._get_auth_plugin()
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 45ff41d..1de09b7 100644
--- a/keystonemiddleware/tests/unit/auth_token/test_auth_token_middleware.py
+++ b/keystonemiddleware/tests/unit/auth_token/test_auth_token_middleware.py
@@ -29,6 +29,7 @@ from keystoneclient import exceptions
 from keystoneclient import fixture
 from keystoneclient import session
 import mock
+from oslo_config import cfg
 from oslo_serialization import jsonutils
 from oslo_utils import timeutils
 import six
@@ -2402,5 +2403,72 @@ class AuthProtocolLoadingTests(BaseAuthTokenMiddlewareTest):
         self.assertEqual(self.project_id, plugin._project_id)
 
 
+class TestAuthPluginUserAgentGeneration(BaseAuthTokenMiddlewareTest):
+
+    def setUp(self):
+        super(TestAuthPluginUserAgentGeneration, self).setUp()
+        self.auth_url = uuid.uuid4().hex
+        self.project_id = uuid.uuid4().hex
+        self.username = uuid.uuid4().hex
+        self.password = uuid.uuid4().hex
+        self.section = uuid.uuid4().hex
+        self.user_domain_id = uuid.uuid4().hex
+
+        auth.register_conf_options(self.cfg.conf, group=self.section)
+        opts = auth.get_plugin_options('password')
+        self.cfg.register_opts(opts, group=self.section)
+
+        # configure the authentication options
+        self.cfg.config(auth_section=self.section, group=_base.AUTHTOKEN_GROUP)
+        self.cfg.config(auth_plugin='password',
+                        password=self.password,
+                        project_id=self.project_id,
+                        user_domain_id=self.user_domain_id,
+                        group=self.section)
+
+    def test_no_project_configured(self):
+        ksm_version = uuid.uuid4().hex
+        conf = {'username': self.username, 'auth_url': self.auth_url}
+
+        app = self._create_app(conf, ksm_version)
+        self._assert_user_agent(app, '', ksm_version)
+
+    def test_project_in_configuration(self):
+        project = uuid.uuid4().hex
+        project_version = uuid.uuid4().hex
+
+        conf = {'username': self.username,
+                'auth_url': self.auth_url,
+                'project': project}
+        app = self._create_app(conf, project_version)
+        project_with_version = '{0}/{1} '.format(project, project_version)
+        self._assert_user_agent(app, project_with_version, project_version)
+
+    def test_project_in_oslo_configuration(self):
+        project = uuid.uuid4().hex
+        project_version = uuid.uuid4().hex
+
+        conf = {'username': self.username, 'auth_url': self.auth_url}
+        with mock.patch.object(cfg.CONF, 'project', new=project, create=True):
+            app = self._create_app(conf, project_version)
+        project = '{0}/{1} '.format(project, project_version)
+        self._assert_user_agent(app, project, project_version)
+
+    def _create_app(self, conf, project_version):
+        fake_pkg_resources = mock.Mock()
+        fake_pkg_resources.get_distribution().version = project_version
+
+        body = uuid.uuid4().hex
+        with mock.patch('keystonemiddleware.auth_token.pkg_resources',
+                        new=fake_pkg_resources):
+            return self.create_simple_middleware(body=body, conf=conf)
+
+    def _assert_user_agent(self, app, project, ksm_version):
+        sess = app._identity_server._adapter.session
+        expected_ua = ('{0}keystonemiddleware.auth_token/{1}'
+                       .format(project, ksm_version))
+        self.assertEqual(expected_ua, sess.user_agent)
+
+
 def load_tests(loader, tests, pattern):
     return testresources.OptimisingTestSuite(tests)