From 6720bf39e5819cb59d262f34964f2337c16958e0 Mon Sep 17 00:00:00 2001 From: Jamie Lennox Date: Tue, 27 May 2014 18:06:48 +1000 Subject: [PATCH] Allow loading auth plugins from CLI With a standard definition of auth plugin options we should be able to load and use those plugins from command line applications. Provide a mechanism to register argparse parameters and load from them. Blueprint: standard-client-params Change-Id: I5d9904fa885602aaaef7a9e0afd4bd6bbfca3f07 --- keystoneclient/auth/cli.py | 93 +++++++++++++++++++++++++++ keystoneclient/tests/auth/test_cli.py | 80 +++++++++++++++++++++++ 2 files changed, 173 insertions(+) create mode 100644 keystoneclient/auth/cli.py create mode 100644 keystoneclient/tests/auth/test_cli.py diff --git a/keystoneclient/auth/cli.py b/keystoneclient/auth/cli.py new file mode 100644 index 000000000..adce3dcab --- /dev/null +++ b/keystoneclient/auth/cli.py @@ -0,0 +1,93 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# 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 argparse +import os + +from keystoneclient.auth import base + +# NOTE(jamielennox): ideally oslo.config would be smart enough to handle all +# the Opt manipulation that goes on in this file. However it is currently not. +# Options are handled in as similar a way as possible to oslo.config such that +# when available we should be able to transition. + + +def register_argparse_arguments(parser, argv): + """Register CLI options needed to create a plugin. + + The function inspects the provided arguments so that it can also register + the options required for that specific plugin if available. + + :param argparse.ArgumentParser: the parser to attach argparse options to. + :param list argv: the arguments provided to the appliation. + + :returns: The plugin class that will be loaded or None if not provided. + + :raises exceptions.NoMatchingPlugin: if a plugin cannot be created. + """ + in_parser = argparse.ArgumentParser(add_help=False) + env_plugin = os.environ.get('OS_AUTH_PLUGIN') + for p in (in_parser, parser): + p.add_argument('--os-auth-plugin', + metavar='', + default=env_plugin, + help='The auth plugin to load') + + options, _args = in_parser.parse_known_args(argv) + + if not options.os_auth_plugin: + return None + + msg = 'Options specific to the %s plugin.' % options.os_auth_plugin + group = parser.add_argument_group('Authentication Options', msg) + plugin = base.get_plugin_class(options.os_auth_plugin) + + for opt in plugin.get_options(): + if opt.default is None: + env_name = opt.name.replace('-', '_').upper() + default = os.environ.get('OS_' + env_name) + else: + default = opt.default + + group.add_argument('--os-' + opt.name, + default=default, + metavar=opt.metavar, + help=opt.help, + dest=opt.dest) + + return plugin + + +def load_from_argparse_arguments(namespace, **kwargs): + """Retrieve the created plugin from the completed argparse results. + + Loads and creates the auth plugin from the information parsed from the + command line by argparse. + + :param Namespace namespace: The result from CLI parsing. + + :returns: An auth plugin, or None if a name is not provided. + + :raises exceptions.NoMatchingPlugin: if a plugin cannot be created. + """ + if not namespace.os_auth_plugin: + return None + + plugin_class = base.get_plugin_class(namespace.os_auth_plugin) + + for opt in plugin_class.get_options(): + val = getattr(namespace, opt.dest) + if val is not None: + val = opt.type(val) + kwargs.setdefault(opt.dest, val) + + return plugin_class.load_from_options(**kwargs) diff --git a/keystoneclient/tests/auth/test_cli.py b/keystoneclient/tests/auth/test_cli.py new file mode 100644 index 000000000..b4580a317 --- /dev/null +++ b/keystoneclient/tests/auth/test_cli.py @@ -0,0 +1,80 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# 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 argparse +import uuid + +from keystoneclient.auth import cli +from keystoneclient.tests.auth import utils + + +class CliTests(utils.TestCase): + + def setUp(self): + super(CliTests, self).setUp() + self.p = argparse.ArgumentParser() + + def test_creating_with_no_args(self): + ret = cli.register_argparse_arguments(self.p, []) + self.assertIsNone(ret) + self.assertIn('--os-auth-plugin', self.p.format_usage()) + + def test_load_with_nothing(self): + cli.register_argparse_arguments(self.p, []) + opts = self.p.parse_args([]) + self.assertIsNone(cli.load_from_argparse_arguments(opts)) + + @utils.mock_plugin + def test_basic_params_added(self, m): + name = uuid.uuid4().hex + argv = ['--os-auth-plugin', name] + ret = cli.register_argparse_arguments(self.p, argv) + self.assertIs(utils.MockPlugin, ret) + + for n in ('--os-a-int', '--os-a-bool', '--os-a-float'): + self.assertIn(n, self.p.format_usage()) + + m.assert_called_once_with(name) + + @utils.mock_plugin + def test_param_loading(self, m): + name = uuid.uuid4().hex + argv = ['--os-auth-plugin', name, + '--os-a-int', str(self.a_int), + '--os-a-float', str(self.a_float), + '--os-a-bool', str(self.a_bool)] + + klass = cli.register_argparse_arguments(self.p, argv) + self.assertIs(utils.MockPlugin, klass) + + opts = self.p.parse_args(argv) + self.assertEqual(name, opts.os_auth_plugin) + + a = cli.load_from_argparse_arguments(opts) + self.assertTestVals(a) + + @utils.mock_plugin + def test_default_options(self, m): + name = uuid.uuid4().hex + argv = ['--os-auth-plugin', name, + '--os-a-float', str(self.a_float)] + + klass = cli.register_argparse_arguments(self.p, argv) + self.assertIs(utils.MockPlugin, klass) + + opts = self.p.parse_args(argv) + self.assertEqual(name, opts.os_auth_plugin) + + a = cli.load_from_argparse_arguments(opts) + + self.assertEqual(self.a_float, a['a_float']) + self.assertEqual(3, a['a_int'])