341 lines
12 KiB
Python
341 lines
12 KiB
Python
# Copyright 2017 - Nokia Networks
|
|
#
|
|
# 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.
|
|
|
|
"""
|
|
Command-line interface to the Glare APIs
|
|
"""
|
|
|
|
import argparse
|
|
import logging
|
|
import sys
|
|
|
|
from cliff import app
|
|
from cliff import commandmanager
|
|
from osc_lib.command import command
|
|
|
|
from glareclient import client
|
|
from glareclient.common import utils
|
|
import glareclient.osc.v1.artifacts
|
|
import glareclient.osc.v1.blobs
|
|
|
|
|
|
class OpenStackHelpFormatter(argparse.HelpFormatter):
|
|
def __init__(self, prog, indent_increment=2, max_help_position=32,
|
|
width=None):
|
|
super(OpenStackHelpFormatter, self).__init__(
|
|
prog,
|
|
indent_increment,
|
|
max_help_position,
|
|
width
|
|
)
|
|
|
|
def start_section(self, heading):
|
|
# Title-case the headings.
|
|
heading = '%s%s' % (heading[0].upper(), heading[1:])
|
|
super(OpenStackHelpFormatter, self).start_section(heading)
|
|
|
|
|
|
class HelpAction(argparse.Action):
|
|
"""Custom help action.
|
|
|
|
Provide a custom action so the -h and --help options
|
|
to the main app will print a list of the commands.
|
|
The commands are determined by checking the CommandManager
|
|
instance, passed in as the "default" value for the action.
|
|
"""
|
|
def __call__(self, parser, namespace, values, option_string=None):
|
|
outputs = []
|
|
max_len = 0
|
|
app = self.default
|
|
parser.print_help(app.stdout)
|
|
app.stdout.write('\nCommands for API v1 :\n')
|
|
|
|
for name, ep in sorted(app.command_manager):
|
|
factory = ep.load()
|
|
cmd = factory(self, None)
|
|
one_liner = cmd.get_description().split('\n')[0]
|
|
outputs.append((name, one_liner))
|
|
max_len = max(len(name), max_len)
|
|
|
|
for (name, one_liner) in outputs:
|
|
app.stdout.write(' %s %s\n' % (name.ljust(max_len), one_liner))
|
|
|
|
sys.exit(0)
|
|
|
|
|
|
class BashCompletionCommand(command.Command):
|
|
"""Prints all of the commands and options for bash-completion."""
|
|
|
|
def take_action(self, parsed_args):
|
|
commands = set()
|
|
options = set()
|
|
|
|
for option, _action in self.app.parser._option_string_actions.items():
|
|
options.add(option)
|
|
|
|
for command_name, _cmd in self.app.command_manager:
|
|
commands.add(command_name)
|
|
|
|
print(' '.join(commands | options))
|
|
|
|
|
|
class GlareShell(app.App):
|
|
|
|
def __init__(self):
|
|
super(GlareShell, self).__init__(
|
|
description=__doc__.strip(),
|
|
version=glareclient.__version__,
|
|
command_manager=commandmanager.CommandManager('glare.cli'),
|
|
)
|
|
self._set_shell_commands(self._get_commands())
|
|
|
|
def configure_logging(self):
|
|
log_lvl = logging.DEBUG if self.options.debug else logging.WARNING
|
|
logging.basicConfig(
|
|
format="%(levelname)s (%(module)s) %(message)s",
|
|
level=log_lvl
|
|
)
|
|
logging.getLogger('iso8601').setLevel(logging.WARNING)
|
|
|
|
if self.options.verbose_level <= 1:
|
|
logging.getLogger('requests').setLevel(logging.WARNING)
|
|
|
|
def build_option_parser(self, description, version,
|
|
argparse_kwargs=None):
|
|
"""Return an argparse option parser for this application.
|
|
|
|
Subclasses may override this method to extend
|
|
the parser with more global options.
|
|
:param description: full description of the application
|
|
:paramtype description: str
|
|
:param version: version number for the application
|
|
:paramtype version: str
|
|
:param argparse_kwargs: extra keyword argument passed to the
|
|
ArgumentParser constructor
|
|
:paramtype extra_kwargs: dict
|
|
"""
|
|
argparse_kwargs = argparse_kwargs or {}
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description=description,
|
|
add_help=False,
|
|
formatter_class=OpenStackHelpFormatter,
|
|
**argparse_kwargs
|
|
)
|
|
parser.add_argument(
|
|
'--version',
|
|
action='version',
|
|
version='%(prog)s {0}'.format(version),
|
|
help='Show program\'s version number and exit.'
|
|
)
|
|
parser.add_argument(
|
|
'-v', '--verbose',
|
|
action='count',
|
|
dest='verbose_level',
|
|
default=self.DEFAULT_VERBOSE_LEVEL,
|
|
help='Increase verbosity of output. Can be repeated.',
|
|
)
|
|
parser.add_argument(
|
|
'--log-file',
|
|
action='store',
|
|
default=None,
|
|
help='Specify a file to log output. Disabled by default.',
|
|
)
|
|
parser.add_argument(
|
|
'-q', '--quiet',
|
|
action='store_const',
|
|
dest='verbose_level',
|
|
const=0,
|
|
help='Suppress output except warnings and errors.',
|
|
)
|
|
parser.add_argument(
|
|
'-h', '--help',
|
|
action=HelpAction,
|
|
nargs=0,
|
|
default=self, # tricky
|
|
help="Show this help message and exit.",
|
|
)
|
|
parser.add_argument(
|
|
'--debug',
|
|
default=False,
|
|
action='store_true',
|
|
help='Show tracebacks on errors.',
|
|
)
|
|
parser.add_argument(
|
|
'--os-glare-url',
|
|
action='store',
|
|
dest='glare_url',
|
|
default=utils.env('OS_GLARE_URL'),
|
|
help='Glare API host (Env: OS_GLARE_URL)'
|
|
)
|
|
parser.add_argument(
|
|
'--os-glare-version',
|
|
action='store',
|
|
dest='glare_version',
|
|
default=utils.env('OS_GLARE_VERSION', default='v1'),
|
|
help='Glare API version (default = v1) (Env: '
|
|
'OS_GLARE_VERSION)'
|
|
)
|
|
parser.add_argument(
|
|
'--keycloak-auth-url',
|
|
action='store',
|
|
dest='keycloak_auth_url',
|
|
default=utils.env('KEYCLOAK_AUTH_URL'),
|
|
help='Keycloak auth url (Env: KEYCLOAK_AUTH_URL)')
|
|
parser.add_argument(
|
|
'--openid-client-id',
|
|
action='store',
|
|
dest='openid_client_id',
|
|
default=utils.env('OPENID_CLIENT_ID') or 'admin-cli',
|
|
help='Client ID (according to OpenID Connect)'
|
|
' (Env: OPENID_CLIENT_ID)')
|
|
parser.add_argument(
|
|
'--auth-token',
|
|
action='store',
|
|
dest='auth_token',
|
|
default=utils.env('AUTH_TOKEN'),
|
|
help='Authentication token (Env: AUTH_TOKEN)')
|
|
parser.add_argument(
|
|
'--keycloak-realm-name',
|
|
action='store',
|
|
dest='keycloak_realm_name',
|
|
default=utils.env('KEYCLOAK_REALM_NAME'),
|
|
help='With keycloak glare auth type: Realm name to scope to'
|
|
' (Env: KEYCLOAK_REALM_NAME)')
|
|
parser.add_argument(
|
|
'--keycloak-username',
|
|
action='store',
|
|
dest='keycloak_username',
|
|
default=utils.env('KEYCLOAK_USERNAME'),
|
|
help='Keycloak username (Env: KEYCLOAK_USERNAME)')
|
|
parser.add_argument(
|
|
'--keycloak-password',
|
|
action='store',
|
|
dest='keycloak_password',
|
|
default=utils.env('KEYCLOAK_PASSWORD'),
|
|
help='Keycloak user password (Env: KEYCLOAK_PASSWORD)')
|
|
parser.add_argument(
|
|
'--cert',
|
|
action='store',
|
|
dest='cert_file',
|
|
default=utils.env('OS_GLARE_CERT'),
|
|
help='Client Certificate (Env: OS_GLARE_CERT)'
|
|
)
|
|
parser.add_argument(
|
|
'--key',
|
|
action='store',
|
|
dest='key_file',
|
|
default=utils.env('OS_GLARE_KEY'),
|
|
help='Client Key (Env: OS_GLARE_KEY)'
|
|
)
|
|
parser.add_argument(
|
|
'--cacert',
|
|
action='store',
|
|
dest='cacert',
|
|
default=utils.env('OS_GLARE_CACERT'),
|
|
help='Authentication CA Certificate (Env: OS_GLARE_CACERT)'
|
|
)
|
|
parser.add_argument(
|
|
'--insecure',
|
|
action='store_true',
|
|
dest='insecure',
|
|
default=utils.env('GLARECLIENT_INSECURE', default=False),
|
|
help='Disables SSL/TLS certificate verification '
|
|
'(Env: GLARELCLIENT_INSECURE)'
|
|
)
|
|
|
|
return parser
|
|
|
|
def initialize_app(self, argv):
|
|
self._clear_shell_commands()
|
|
self._set_shell_commands(self._get_commands())
|
|
|
|
# bash-completion and help messages should not require client creation
|
|
need_client = not (
|
|
('bash-completion' in argv) or
|
|
('help' in argv) or
|
|
('-h' in argv) or
|
|
('--help' in argv) or
|
|
not argv)
|
|
|
|
self.client = self._create_client() if need_client else None
|
|
|
|
# Adding client_manager variable to make glare client work with
|
|
# unified OpenStack client.
|
|
ClientManager = type(
|
|
'ClientManager',
|
|
(object,),
|
|
dict(artifact=self.client)
|
|
)
|
|
|
|
self.client_manager = ClientManager()
|
|
|
|
def _create_client(self):
|
|
return client.Client(
|
|
endpoint=self.options.glare_url,
|
|
auth_token=self.options.auth_token,
|
|
keycloak_auth_url=self.options.keycloak_auth_url,
|
|
openid_client_id=self.options.openid_client_id,
|
|
keycloak_realm_name=self.options.keycloak_realm_name,
|
|
keycloak_username=self.options.keycloak_username,
|
|
keycloak_password=self.options.keycloak_password,
|
|
cert_file=self.options.cert_file,
|
|
key_file=self.options.key_file,
|
|
cacert=self.options.cacert,
|
|
insecure=self.options.insecure
|
|
)
|
|
|
|
def _set_shell_commands(self, cmds_dict):
|
|
for k, v in cmds_dict.items():
|
|
self.command_manager.add_command(k, v)
|
|
|
|
def _clear_shell_commands(self):
|
|
exclude_cmds = ['help', 'complete']
|
|
|
|
cmds = self.command_manager.commands.copy()
|
|
for k, v in cmds.items():
|
|
if k not in exclude_cmds:
|
|
self.command_manager.commands.pop(k)
|
|
|
|
@staticmethod
|
|
def _get_commands():
|
|
return {
|
|
'bash-completion': BashCompletionCommand,
|
|
'list': glareclient.osc.v1.artifacts.ListArtifacts,
|
|
'show': glareclient.osc.v1.artifacts.ShowArtifact,
|
|
'create': glareclient.osc.v1.artifacts.CreateArtifact,
|
|
'delete': glareclient.osc.v1.artifacts.DeleteArtifact,
|
|
'update': glareclient.osc.v1.artifacts.UpdateArtifact,
|
|
'activate': glareclient.osc.v1.artifacts.ActivateArtifact,
|
|
'deactivate': glareclient.osc.v1.artifacts.DeactivateArtifact,
|
|
'reactivate': glareclient.osc.v1.artifacts.ReactivateArtifact,
|
|
'publish': glareclient.osc.v1.artifacts.PublishArtifact,
|
|
'add-tag': glareclient.osc.v1.artifacts.AddTag,
|
|
'remove-tag': glareclient.osc.v1.artifacts.RemoveTag,
|
|
'type-list': glareclient.osc.v1.artifacts.TypeList,
|
|
'schema': glareclient.osc.v1.artifacts.TypeSchema,
|
|
'upload': glareclient.osc.v1.blobs.UploadBlob,
|
|
'download': glareclient.osc.v1.blobs.DownloadBlob,
|
|
'location': glareclient.osc.v1.blobs.AddLocation,
|
|
'remove-location': glareclient.osc.v1.blobs.RemoveLocation
|
|
}
|
|
|
|
|
|
def main(argv=sys.argv[1:]):
|
|
return GlareShell().run(argv)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main(sys.argv[1:]))
|