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

@@ -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='<name>',
+                       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)

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'])