Add support for client redirecting to aodh endpoint if available

Currently, alarm module of ceilometer has been decided to be splitted out
of ceilometer tree. To keep compatibility for others upstream users
(such as Heat), we need to redirect alarm related request to aodh endpoint.

Change-Id: Id13b56eef55f807d5ad2026f225c93fd5585521e

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