Merge "Add support for client redirecting to aodh endpoint if available"

6 files changed, 259 insertions, 60 deletions

diff --git a/ceilometerclient/client.py b/ceilometerclient/client.py
index a3fbba5..4f9f3da 100644
--- a/ceilometerclient/client.py
+++ b/ceilometerclient/client.py
@@ -129,6 +129,66 @@ def _get_keystone_session(**kwargs):
     return ks_session
 
 
+def _get_token_auth_ks_session(**kwargs):
+
+    cacert = kwargs.pop('cacert', None)
+    cert = kwargs.pop('cert', None)
+    key = kwargs.pop('key', None)
+    insecure = kwargs.pop('insecure', False)
+    auth_url = kwargs.pop('auth_url', None)
+    project_id = kwargs.pop('project_id', None)
+    project_name = kwargs.pop('project_name', None)
+    timeout = kwargs.get('timeout')
+    token = kwargs['token']
+
+    if insecure:
+        verify = False
+    else:
+        verify = cacert or True
+
+    if cert and key:
+        # passing cert and key together is deprecated in favour of the
+        # requests lib form of having the cert and key as a tuple
+        cert = (cert, key)
+
+    # create the keystone client session
+    ks_session = session.Session(verify=verify, cert=cert, timeout=timeout)
+    v2_auth_url, v3_auth_url = _discover_auth_versions(ks_session, auth_url)
+
+    user_domain_name = kwargs.pop('user_domain_name', None)
+    user_domain_id = kwargs.pop('user_domain_id', None)
+    project_domain_name = kwargs.pop('project_domain_name', None)
+    project_domain_id = kwargs.pop('project_domain_id', None)
+    auth = None
+
+    use_domain = (user_domain_id or user_domain_name or
+                  project_domain_id or project_domain_name)
+    use_v3 = v3_auth_url and (use_domain or (not v2_auth_url))
+    use_v2 = v2_auth_url and not use_domain
+
+    if use_v3:
+        auth = v3_auth.Token(
+            v3_auth_url,
+            token=token,
+            project_name=project_name,
+            project_id=project_id,
+            project_domain_name=project_domain_name,
+            project_domain_id=project_domain_id)
+    elif use_v2:
+        auth = v2_auth.Token(
+            v2_auth_url,
+            token=token,
+            tenant_id=project_id,
+            tenant_name=project_name)
+    else:
+        raise exc.CommandError('Unable to determine the Keystone version '
+                               'to authenticate with using the given '
+                               'auth_url.')
+
+    ks_session.auth = auth
+    return ks_session
+
+
 def _get_endpoint(ks_session, **kwargs):
     """Get an endpoint using the provided keystone session."""
 
@@ -160,32 +220,7 @@ class AuthPlugin(auth.BaseAuthPlugin):
         token = self.opts.get('token') or self.opts.get('auth_token')
         endpoint = self.opts.get('endpoint')
         if not (token and endpoint):
-            project_id = (self.opts.get('project_id') or
-                          self.opts.get('tenant_id'))
-            project_name = (self.opts.get('project_name') or
-                            self.opts.get('tenant_name'))
-            ks_kwargs = {
-                'username': self.opts.get('username'),
-                'password': self.opts.get('password'),
-                'user_id': self.opts.get('user_id'),
-                'user_domain_id': self.opts.get('user_domain_id'),
-                'user_domain_name': self.opts.get('user_domain_name'),
-                'project_id': project_id,
-                'project_name': project_name,
-                'project_domain_name': self.opts.get('project_domain_name'),
-                'project_domain_id': self.opts.get('project_domain_id'),
-                'auth_url': self.opts.get('auth_url'),
-                'cacert': self.opts.get('cacert'),
-                'cert': self.opts.get('cert'),
-                'key': self.opts.get('key'),
-                'insecure': strutils.bool_from_string(
-                    self.opts.get('insecure')),
-                'endpoint_type': self.opts.get('endpoint_type'),
-                'region_name': self.opts.get('region_name'),
-                'timeout': http_client.timeout,
-            }
-
-            # retrieve session
+            ks_kwargs = self._get_ks_kwargs(http_timeout=http_client.timeout)
             ks_session = _get_keystone_session(**ks_kwargs)
             token = lambda: ks_session.get_token()
             endpoint = (self.opts.get('endpoint') or
@@ -193,6 +228,48 @@ class AuthPlugin(auth.BaseAuthPlugin):
         self.opts['token'] = token
         self.opts['endpoint'] = endpoint
 
+    def _get_ks_kwargs(self, http_timeout):
+        project_id = (self.opts.get('project_id') or
+                      self.opts.get('tenant_id'))
+        project_name = (self.opts.get('project_name') or
+                        self.opts.get('tenant_name'))
+        ks_kwargs = {
+            'username': self.opts.get('username'),
+            'password': self.opts.get('password'),
+            'user_id': self.opts.get('user_id'),
+            'user_domain_id': self.opts.get('user_domain_id'),
+            'user_domain_name': self.opts.get('user_domain_name'),
+            'project_id': project_id,
+            'project_name': project_name,
+            'project_domain_name': self.opts.get('project_domain_name'),
+            'project_domain_id': self.opts.get('project_domain_id'),
+            'auth_url': self.opts.get('auth_url'),
+            'cacert': self.opts.get('cacert'),
+            'cert': self.opts.get('cert'),
+            'key': self.opts.get('key'),
+            'insecure': strutils.bool_from_string(
+                self.opts.get('insecure')),
+            'endpoint_type': self.opts.get('endpoint_type'),
+            'region_name': self.opts.get('region_name'),
+            'timeout': http_timeout,
+        }
+        return ks_kwargs
+
+    def redirect_to_aodh_endpoint(self, http_timeout):
+        ks_kwargs = self._get_ks_kwargs(http_timeout)
+        token = self.opts.get('token') or self.opts.get('auth_token')
+        # NOTE(liusheng): if token provided, we try to get keystone session
+        # with token, else, we get keystone session with user info and
+        # password. And then use the keystone session to get aodh's endpoint.
+        if token:
+            token = token() if callable(token) else token
+            ks_kwargs.update(token=token)
+            ks_session = _get_token_auth_ks_session(**ks_kwargs)
+        else:
+            ks_session = _get_keystone_session(**ks_kwargs)
+        ks_kwargs.update(service_type='alarming')
+        self.opts['endpoint'] = _get_endpoint(ks_session, **ks_kwargs)
+
     def token_and_endpoint(self, endpoint_type, service_type):
         token = self.opts.get('token')
         if callable(token):
@@ -325,7 +402,7 @@ def get_auth_plugin(endpoint, **kwargs):
         endpoint=endpoint,
         username=kwargs.get('username'),
         password=kwargs.get('password'),
-        tenant_name=kwargs.get('tenant_name'),
+        tenant_name=kwargs.get('tenant_name') or kwargs.get('project_name'),
         user_domain_name=kwargs.get('user_domain_name'),
         user_domain_id=kwargs.get('user_domain_id'),
         project_domain_name=kwargs.get('project_domain_name'),
diff --git a/ceilometerclient/tests/unit/test_client.py b/ceilometerclient/tests/unit/test_client.py
index ffd47df..b4e1f65 100644
--- a/ceilometerclient/tests/unit/test_client.py
+++ b/ceilometerclient/tests/unit/test_client.py
@@ -31,8 +31,8 @@ FAKE_ENV = {
     'password': 'password',
     'tenant_name': 'tenant_name',
     'auth_url': 'http://no.where',
+    'auth_plugin': mock.Mock(),
     'ceilometer_url': 'http://no.where',
-    'auth_plugin': 'fake_auth',
     'token': '1234',
     'user_domain_name': 'default',
     'project_domain_name': 'default',
@@ -40,13 +40,19 @@ FAKE_ENV = {
 
 
 class ClientTest(utils.BaseTestCase):
-
     @staticmethod
     def create_client(env, api_version=2, endpoint=None, exclude=[]):
         env = dict((k, v) for k, v in env.items()
                    if k not in exclude)
-
-        return client.get_client(api_version, **env)
+        if not env.get('auth_plugin'):
+            with mock.patch('ceilometerclient.client.AuthPlugin.'
+                            'redirect_to_aodh_endpoint') as redirect_aodh:
+                redirect_aodh.side_effect = ks_exc.EndpointNotFound
+                return client.get_client(api_version, **env)
+        else:
+            env['auth_plugin'].redirect_to_aodh_endpoint.side_effect = \
+                ks_exc.EndpointNotFound
+            return client.get_client(api_version, **env)
 
     def test_client_version(self):
         c1 = self.create_client(env=FAKE_ENV, api_version=1)
@@ -102,10 +108,6 @@ class ClientTest(utils.BaseTestCase):
             self.create_client(env, api_version=2, endpoint='http://no.where')
             auth_plugin.assert_called_with(**expected)
 
-    def test_client_with_auth_plugin(self):
-        c = self.create_client(FAKE_ENV, api_version=2)
-        self.assertIsInstance(c.auth_plugin, str)
-
     def test_v2_client_timeout_invalid_value(self):
         env = FAKE_ENV.copy()
         env['timeout'] = 'abc'
@@ -117,7 +119,7 @@ class ClientTest(utils.BaseTestCase):
         env = FAKE_ENV.copy()
         env['timeout'] = timeout
         expected = {
-            'auth_plugin': 'fake_auth',
+            'auth_plugin': mock.ANY,
             'timeout': expected_value,
             'original_ip': None,
             'http': None,
@@ -181,9 +183,44 @@ class ClientTest2(ClientTest):
     def create_client(env, api_version=2, endpoint=None, exclude=[]):
         env = dict((k, v) for k, v in env.items()
                    if k not in exclude)
+        if not env.get('auth_plugin'):
+            with mock.patch('ceilometerclient.client.AuthPlugin.'
+                            'redirect_to_aodh_endpoint') as redirect_aodh:
+                redirect_aodh.side_effect = ks_exc.EndpointNotFound
+                return client.Client(api_version, endpoint, **env)
+        else:
+            env['auth_plugin'].redirect_to_aodh_endpoint.side_effect = \
+                ks_exc.EndpointNotFound
+            return client.Client(api_version, endpoint, **env)
+
+
+class ClientTestWithAodh(ClientTest):
+    @staticmethod
+    def create_client(env, api_version=2, endpoint=None, exclude=[]):
+        env = dict((k, v) for k, v in env.items()
+                   if k not in exclude)
+        if not env.get('auth_plugin'):
+            with mock.patch('ceilometerclient.client.AuthPlugin.'
+                            'redirect_to_aodh_endpoint'):
+                return client.get_client(api_version, **env)
+        else:
+            env['auth_plugin'].redirect_to_aodh_endpoint = mock.MagicMock()
+            return client.get_client(api_version, **env)
 
-        # Run the same tests with direct instantiation of the Client
-        return client.Client(api_version, endpoint, **env)
+    @mock.patch('keystoneclient.v2_0.client', fakes.FakeKeystone)
+    def test_client_without_auth_plugin(self):
+        env = FAKE_ENV.copy()
+        del env['auth_plugin']
+        c = self.create_client(env, api_version=2, endpoint='fake_endpoint')
+        self.assertIsInstance(c.alarm_auth_plugin, client.AuthPlugin)
+
+    def test_v2_client_insecure(self):
+        env = FAKE_ENV.copy()
+        env.pop('auth_plugin')
+        env['insecure'] = 'True'
+        client = self.create_client(env)
+        self.assertIn('insecure', client.alarm_auth_plugin.opts)
+        self.assertEqual('True', client.alarm_auth_plugin.opts['insecure'])
 
 
 class ClientAuthTest(utils.BaseTestCase):
@@ -209,10 +246,10 @@ class ClientAuthTest(utils.BaseTestCase):
         client.auth_plugin._do_authenticate(mock.MagicMock())
 
         self.assertEqual([mock.call(auth_url='http://no.where',
+                                    session=mock_session_instance),
+                          mock.call(auth_url='http://no.where',
                                     session=mock_session_instance)],
                          discover_mock.call_args_list)
-        # discover_mock.assert_called(auth_url='http://no.where',
-        #                             session=mock_session_instance)
         self.assertIsInstance(mock_session_instance.auth, v3_auth.Password)
 
     @mock.patch('keystoneclient.discover.Discover')
@@ -237,6 +274,8 @@ class ClientAuthTest(utils.BaseTestCase):
         client.auth_plugin.opts.pop('token', None)
         client.auth_plugin._do_authenticate(mock.MagicMock())
         self.assertEqual([mock.call(auth_url='http://no.where',
+                                    session=session_instance_mock),
+                          mock.call(auth_url='http://no.where',
                                     session=session_instance_mock)],
                          discover.call_args_list)
 
@@ -257,14 +296,20 @@ class ClientAuthTest(utils.BaseTestCase):
         discover_instance_mock.url_for.side_effect = (lambda v: v
                                                       if v == '2.0' else None)
         discover.side_effect = ks_exc.DiscoveryFailure
-
+        self.assertRaises(ks_exc.DiscoveryFailure, self.create_client, env)
+        discover.side_effect = mock.MagicMock()
         client = self.create_client(env)
+        discover.side_effect = ks_exc.DiscoveryFailure
         client.auth_plugin.opts.pop('token', None)
 
         self.assertRaises(ks_exc.DiscoveryFailure,
                           client.auth_plugin._do_authenticate,
                           mock.Mock())
         self.assertEqual([mock.call(auth_url='http://no.where',
+                                    session=session_instance_mock),
+                          mock.call(auth_url='http://no.where',
+                                    session=session_instance_mock),
+                          mock.call(auth_url='http://no.where',
                                     session=session_instance_mock)],
                          discover.call_args_list)
 
@@ -279,7 +324,13 @@ class ClientAuthTest(utils.BaseTestCase):
 
         discover.side_effect = exceptions.ClientException
 
-        client = self.create_client(env)
+        # the redirect_to_aodh_endpoint method will raise CommandError if
+        # didn't specify keystone api version
+        self.assertRaises(exc.CommandError, self.create_client, env)
+        with mock.patch('ceilomet'
+                        'erclient.client.AuthPlugin.'
+                        'redirect_to_aodh_endpoint'):
+            client = self.create_client(env)
         client.auth_plugin.opts.pop('token', None)
 
         self.assertRaises(exc.CommandError,
@@ -287,23 +338,42 @@ class ClientAuthTest(utils.BaseTestCase):
                           mock.Mock())
 
     @mock.patch('ceilometerclient.client._get_keystone_session')
-    def test_get_endpoint(self, session):
+    @mock.patch('ceilometerclient.client._get_token_auth_ks_session')
+    def test_get_endpoint(self, token_session, session):
         env = FAKE_ENV.copy()
         env.pop('auth_plugin', None)
         env.pop('endpoint', None)
 
         session_instance_mock = mock.MagicMock()
         session.return_value = session_instance_mock
+        token_ks_session_mock = mock.MagicMock()
+        token_session.return_value = token_ks_session_mock
 
         client = self.create_client(env)
+        token_ks_session_mock.get_endpoint.assert_called_with(
+            interface='publicURL', region_name=None, service_type='alarming')
         client.auth_plugin.opts.pop('token', None)
         client.auth_plugin.opts.pop('endpoint')
         client.auth_plugin._do_authenticate(mock.MagicMock())
         session_instance_mock.get_endpoint.assert_called_with(
             region_name=None, interface='publicURL', service_type='metering')
 
+    @mock.patch('ceilometerclient.client._get_token_auth_ks_session')
+    def test_get_aodh_endpoint(self, session):
+        env = FAKE_ENV.copy()
+        env.pop('auth_plugin', None)
+        env.pop('endpoint', None)
+
+        session_instance_mock = mock.MagicMock()
+        session.return_value = session_instance_mock
+
+        self.create_client(env)
+        session_instance_mock.get_endpoint.assert_called_with(
+            region_name=None, interface='publicURL', service_type='alarming')
+
     @mock.patch('ceilometerclient.client._get_keystone_session')
-    def test_get_different_endpoint_type(self, session):
+    @mock.patch('ceilometerclient.client._get_token_auth_ks_session')
+    def test_get_different_endpoint_type(self, token_session, session):
         env = FAKE_ENV.copy()
         env.pop('auth_plugin', None)
         env.pop('endpoint', None)
@@ -311,8 +381,12 @@ class ClientAuthTest(utils.BaseTestCase):
 
         session_instance_mock = mock.MagicMock()
         session.return_value = session_instance_mock
+        token_ks_session_mock = mock.MagicMock()
+        token_session.return_value = token_ks_session_mock
 
         client = self.create_client(env)
+        token_ks_session_mock.get_endpoint.assert_called_with(
+            interface='internal', region_name=None, service_type='alarming')
         client.auth_plugin.opts.pop('token', None)
         client.auth_plugin.opts.pop('endpoint')
         client.auth_plugin._do_authenticate(mock.MagicMock())
@@ -320,7 +394,8 @@ class ClientAuthTest(utils.BaseTestCase):
             region_name=None, interface='internal', service_type='metering')
 
     @mock.patch('ceilometerclient.client._get_keystone_session')
-    def test_get_sufficient_options_missing(self, session):
+    @mock.patch('ceilometerclient.client._get_token_auth_ks_session')
+    def test_get_sufficient_options_missing(self, token_session, session):
         env = FAKE_ENV.copy()
         env.pop('auth_plugin', None)
         env.pop('password', None)
diff --git a/ceilometerclient/tests/unit/test_shell.py b/ceilometerclient/tests/unit/test_shell.py
index 4f8dd4f..129df2f 100644
--- a/ceilometerclient/tests/unit/test_shell.py
+++ b/ceilometerclient/tests/unit/test_shell.py
@@ -113,14 +113,16 @@ class ShellBashCompletionTest(ShellTestBase):
 class ShellKeystoneV2Test(ShellTestBase):
 
     @mock.patch.object(ks_session, 'Session')
-    def test_debug_switch_raises_error(self, mock_ksclient):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_debug_switch_raises_error(self, aodh_redirect, mock_ksclient):
         mock_ksclient.side_effect = exc.HTTPUnauthorized
         self.make_env(FAKE_V2_ENV)
         args = ['--debug', 'event-list']
         self.assertRaises(exc.CommandError, ceilometer_shell.main, args)
 
     @mock.patch.object(ks_session, 'Session')
-    def test_dash_d_switch_raises_error(self, mock_ksclient):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_dash_d_switch_raises_error(self, aodh_redirect, mock_ksclient):
         mock_ksclient.side_effect = exc.CommandError("FAIL")
         self.make_env(FAKE_V2_ENV)
         args = ['-d', 'event-list']
@@ -189,7 +191,8 @@ class ShellTimeoutTest(ShellTestBase):
         self._test_timeout('0', expected_msg)
 
     @mock.patch.object(ks_session, 'Session')
-    def test_timeout_keystone_session(self, mocked_session):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_timeout_keystone_session(self, aodh_redirect, mocked_session):
         mocked_session.side_effect = exc.HTTPUnauthorized("FAIL")
         self.make_env(FAKE_V2_ENV)
         args = ['--debug', '--timeout', '5', 'alarm-list']
@@ -201,7 +204,8 @@ class ShellTimeoutTest(ShellTestBase):
 class ShellInsecureTest(ShellTestBase):
 
     @mock.patch.object(api_client, 'HTTPClient')
-    def test_insecure_true_ceilometer(self, mocked_client):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_insecure_true_ceilometer(self, aodh_redirect, mocked_client):
         self.make_env(FAKE_V2_ENV)
         args = ['--debug', '--os-insecure', 'true', 'alarm-list']
         self.assertIsNone(ceilometer_shell.main(args))
@@ -209,7 +213,8 @@ class ShellInsecureTest(ShellTestBase):
         self.assertEqual(False, kwargs.get('verify'))
 
     @mock.patch.object(ks_session, 'Session')
-    def test_insecure_true_keystone(self, mocked_session):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_insecure_true_keystone(self, aodh_redirect, mocked_session):
         mocked_session.side_effect = exc.HTTPUnauthorized("FAIL")
         self.make_env(FAKE_V2_ENV)
         args = ['--debug', '--os-insecure', 'true', 'alarm-list']
@@ -218,7 +223,8 @@ class ShellInsecureTest(ShellTestBase):
         self.assertEqual(False, kwargs.get('verify'))
 
     @mock.patch.object(api_client, 'HTTPClient')
-    def test_insecure_false_ceilometer(self, mocked_client):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_insecure_false_ceilometer(self, aodh_redirect, mocked_client):
         self.make_env(FAKE_V2_ENV)
         args = ['--debug', '--os-insecure', 'false', 'alarm-list']
         self.assertIsNone(ceilometer_shell.main(args))
@@ -226,7 +232,8 @@ class ShellInsecureTest(ShellTestBase):
         self.assertEqual(True, kwargs.get('verify'))
 
     @mock.patch.object(ks_session, 'Session')
-    def test_insecure_false_keystone(self, mocked_session):
+    @mock.patch('ceilometerclient.client.AuthPlugin.redirect_to_aodh_endpoint')
+    def test_insecure_false_keystone(self, aodh_redirect, mocked_session):
         mocked_session.side_effect = exc.HTTPUnauthorized("FAIL")
         self.make_env(FAKE_V2_ENV)
         args = ['--debug', '--os-insecure', 'false', 'alarm-list']
diff --git a/ceilometerclient/tests/unit/v2/test_shell.py b/ceilometerclient/tests/unit/v2/test_shell.py
index 6cc5985..358e3a4 100644
--- a/ceilometerclient/tests/unit/v2/test_shell.py
+++ b/ceilometerclient/tests/unit/v2/test_shell.py
@@ -37,6 +37,7 @@ from ceilometerclient.v2 import shell as ceilometer_shell
 from ceilometerclient.v2 import statistics
 from ceilometerclient.v2 import trait_descriptions
 from ceilometerclient.v2 import traits
+from keystoneclient import exceptions
 
 
 class ShellAlarmStateCommandsTest(utils.BaseTestCase):
@@ -1231,7 +1232,10 @@ class ShellShadowedArgsTest(test_shell.ShellTestBase):
             '--user-id', 'the-user-id-i-want-to-set',
             '--name', 'project-id-test'] + args
         with mock.patch.object(alarms.AlarmManager, method) as mocked:
-            base_shell.main(cli_args)
+            with mock.patch('ceilometerclient.client.AuthPlugin.'
+                            'redirect_to_aodh_endpoint') as redirect_aodh:
+                redirect_aodh.site_effect = exceptions.EndpointNotFound
+                base_shell.main(cli_args)
         args, kwargs = mocked.call_args
         self.assertEqual('the-project-id-i-want-to-set',
                          kwargs.get('project_id'))
@@ -1272,7 +1276,10 @@ class ShellShadowedArgsTest(test_shell.ShellTestBase):
             '--meter-unit', 'ns',
             '--sample-volume', '10086',
         ]
-        base_shell.main(cli_args)
+        with mock.patch('ceilometerclient.client.AuthPlugin.'
+                        'redirect_to_aodh_endpoint') as redirect_aodh:
+            redirect_aodh.site_effect = exceptions.EndpointNotFound
+            base_shell.main(cli_args)
         args, kwargs = mocked.call_args
         self.assertEqual('the-project-id-i-want-to-set',
                          kwargs.get('project_id'))
diff --git a/ceilometerclient/v2/alarms.py b/ceilometerclient/v2/alarms.py
index bc8e999..e7dfd36 100644
--- a/ceilometerclient/v2/alarms.py
+++ b/ceilometerclient/v2/alarms.py
@@ -70,8 +70,13 @@ class AlarmChange(base.Resource):
 class AlarmManager(base.Manager):
     resource_class = Alarm
 
-    @staticmethod
-    def _path(id=None):
+    def __init__(self, api, aodh_enabled=False):
+        self.aodh_enabled = aodh_enabled
+        super(AlarmManager, self).__init__(api)
+
+    def _path(self, id=None):
+        # TODO(liusheng) if aodh will only have v1 api, we need to change
+        # following path if aodh enabled (self.aodh_enabled)
         return '/v2/alarms/%s' % id if id else '/v2/alarms'
 
     def list(self, q=None):
diff --git a/ceilometerclient/v2/client.py b/ceilometerclient/v2/client.py
index 31e8144..8813860 100644
--- a/ceilometerclient/v2/client.py
+++ b/ceilometerclient/v2/client.py
@@ -14,6 +14,7 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+import copy
 
 from ceilometerclient import client as ceiloclient
 from ceilometerclient.openstack.common.apiclient import client
@@ -28,6 +29,7 @@ from ceilometerclient.v2 import samples
 from ceilometerclient.v2 import statistics
 from ceilometerclient.v2 import trait_descriptions
 from ceilometerclient.v2 import traits
+from keystoneclient import exceptions
 
 
 class Client(object):
@@ -63,12 +65,13 @@ class Client(object):
         )
 
         self.http_client = client.BaseClient(self.client)
+        self.alarm_client, aodh_enabled = self._get_alarm_client(**kwargs)
         self.meters = meters.MeterManager(self.http_client)
         self.samples = samples.OldSampleManager(self.http_client)
         self.new_samples = samples.SampleManager(self.http_client)
         self.statistics = statistics.StatisticsManager(self.http_client)
         self.resources = resources.ResourceManager(self.http_client)
-        self.alarms = alarms.AlarmManager(self.http_client)
+        self.alarms = alarms.AlarmManager(self.alarm_client, aodh_enabled)
         self.events = events.EventManager(self.http_client)
         self.event_types = event_types.EventTypeManager(self.http_client)
         self.traits = traits.TraitManager(self.http_client)
@@ -77,8 +80,33 @@ class Client(object):
 
         self.query_samples = query.QuerySamplesManager(
             self.http_client)
-        self.query_alarms = query.QueryAlarmsManager(
-            self.http_client)
+        self.query_alarms = query.QueryAlarmsManager(self.alarm_client)
         self.query_alarm_history = query.QueryAlarmHistoryManager(
-            self.http_client)
+            self.alarm_client)
         self.capabilities = capabilities.CapabilitiesManager(self.http_client)
+
+    def _get_alarm_client(self, **kwargs):
+        """Get client for alarm manager that redirect to aodh."""
+        self.alarm_auth_plugin = copy.deepcopy(self.auth_plugin)
+        try:
+            # NOTE(liusheng): Getting the aodh's endpoint to rewrite
+            # the endpoint of alarm auth_plugin.
+            self.alarm_auth_plugin.redirect_to_aodh_endpoint(
+                kwargs.get('timeout'))
+        except exceptions.EndpointNotFound:
+            return self.http_client, False
+        alarm_client = client.HTTPClient(
+            auth_plugin=self.alarm_auth_plugin,
+            region_name=kwargs.get('region_name'),
+            endpoint_type=kwargs.get('endpoint_type'),
+            original_ip=kwargs.get('original_ip'),
+            verify=kwargs.get('verify'),
+            cert=kwargs.get('cert'),
+            timeout=kwargs.get('timeout'),
+            timings=kwargs.get('timings'),
+            keyring_saver=kwargs.get('keyring_saver'),
+            debug=kwargs.get('debug'),
+            user_agent=kwargs.get('user_agent'),
+            http=kwargs.get('http')
+        )
+        return client.BaseClient(alarm_client), True