Statistics
| Branch: | Tag: | Revision:

root / kamaki / cli / __init__.py @ b8220825

History | View | Annotate | Download (18.9 kB)

1
# Copyright 2012-2014 GRNET S.A. All rights reserved.
2
#
3
# Redistribution and use in source and binary forms, with or
4
# without modification, are permitted provided that the following
5
# conditions are met:
6
#
7
#   1. Redistributions of source code must retain the above
8
#      copyright notice, this list of conditions and the following
9
#      disclaimer.
10
#
11
#   2. Redistributions in binary form must reproduce the above
12
#      copyright notice, this list of conditions and the following
13
#      disclaimer in the documentation and/or other materials
14
#      provided with the distribution.
15
#
16
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
17
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
20
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
26
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27
# POSSIBILITY OF SUCH DAMAGE.
28
#
29
# The views and conclusions contained in the software and
30
# documentation are those of the authors and should not be
31
# interpreted as representing official policies, either expressed
32
# or implied, of GRNET S.A.command
33

    
34
import logging
35
from sys import argv, exit, stdout, stderr
36
from os.path import basename, exists
37
from inspect import getargspec
38

    
39
from kamaki.cli.argument import ArgumentParseManager
40
from kamaki.cli.history import History
41
from kamaki.cli.utils import print_dict, red, magenta, yellow
42
from kamaki.cli.errors import CLIError, CLICmdSpecError
43
from kamaki.cli import logger
44
from kamaki.clients.astakos import CachedAstakosClient
45
from kamaki.clients import ClientError
46

    
47
_help = False
48
_debug = False
49
_verbose = False
50
_colors = False
51
kloger = None
52
filelog = None
53

    
54
#  command auxiliary methods
55

    
56
_best_match = []
57

    
58

    
59
def _arg2syntax(arg):
60
    return arg.replace(
61
        '____', '[:').replace(
62
            '___', ':').replace(
63
                '__', ']').replace(
64
                    '_', ' ')
65

    
66

    
67
def _construct_command_syntax(cls):
68
        spec = getargspec(cls.main.im_func)
69
        args = spec.args[1:]
70
        n = len(args) - len(spec.defaults or ())
71
        required = ' '.join(['<%s>' % _arg2syntax(x) for x in args[:n]])
72
        optional = ' '.join(['[%s]' % _arg2syntax(x) for x in args[n:]])
73
        cls.syntax = ' '.join([required, optional])
74
        if spec.varargs:
75
            cls.syntax += ' <%s ...>' % spec.varargs
76

    
77

    
78
def _num_of_matching_terms(basic_list, attack_list):
79
    if not attack_list:
80
        return len(basic_list)
81

    
82
    matching_terms = 0
83
    for i, term in enumerate(basic_list):
84
        try:
85
            if term != attack_list[i]:
86
                break
87
        except IndexError:
88
            break
89
        matching_terms += 1
90
    return matching_terms
91

    
92

    
93
def _update_best_match(name_terms, prefix=[]):
94
    if prefix:
95
        pref_list = prefix if isinstance(prefix, list) else prefix.split('_')
96
    else:
97
        pref_list = []
98

    
99
    num_of_matching_terms = _num_of_matching_terms(name_terms, pref_list)
100
    global _best_match
101
    if not prefix:
102
        _best_match = []
103

    
104
    if num_of_matching_terms and len(_best_match) <= num_of_matching_terms:
105
        if len(_best_match) < num_of_matching_terms:
106
            _best_match = name_terms[:num_of_matching_terms]
107
        return True
108
    return False
109

    
110

    
111
def command(cmd_tree, prefix='', descedants_depth=1):
112
    """Load a class as a command
113
        e.g., spec_cmd0_cmd1 will be command spec cmd0
114

115
        :param cmd_tree: is initialized in cmd_spec file and is the structure
116
            where commands are loaded. Var name should be _commands
117
        :param prefix: if given, load only commands prefixed with prefix,
118
        :param descedants_depth: is the depth of the tree descedants of the
119
            prefix command. It is used ONLY if prefix and if prefix is not
120
            a terminal command
121

122
        :returns: the specified class object
123
    """
124

    
125
    def wrap(cls):
126
        global kloger
127
        cls_name = cls.__name__
128

    
129
        if not cmd_tree:
130
            if _debug:
131
                kloger.warning('command %s found but not loaded' % cls_name)
132
            return cls
133

    
134
        name_terms = cls_name.split('_')
135
        if not _update_best_match(name_terms, prefix):
136
            # if _debug:
137
            #     kloger.warning('%s failed to update_best_match' % cls_name)
138
            return None
139

    
140
        global _best_match
141
        max_len = len(_best_match) + descedants_depth
142
        if len(name_terms) > max_len:
143
            partial = '_'.join(name_terms[:max_len])
144
            if not cmd_tree.has_command(partial):  # add partial path
145
                cmd_tree.add_command(partial)
146
            if _debug:
147
                kloger.warning('%s failed max_len test' % cls_name)
148
            return None
149

    
150
        try:
151
            (
152
                cls.description, sep, cls.long_description
153
            ) = cls.__doc__.partition('\n')
154
        except AttributeError:
155
            raise CLICmdSpecError(
156
                'No commend in %s (acts as cmd description)' % cls.__name__)
157
        _construct_command_syntax(cls)
158

    
159
        cmd_tree.add_command(
160
            cls_name, cls.description, cls, cls.long_description)
161
        return cls
162
    return wrap
163

    
164

    
165
cmd_spec_locations = [
166
    'kamaki.cli.commands',
167
    'kamaki.commands',
168
    'kamaki.cli',
169
    'kamaki',
170
    '']
171

    
172

    
173
#  Generic init auxiliary functions
174

    
175

    
176
def _setup_logging(silent=False, debug=False, verbose=False):
177
    """handle logging for clients package"""
178

    
179
    if silent:
180
        logger.add_stream_logger(__name__, logging.CRITICAL)
181
        return
182

    
183
    sfmt, rfmt = '> %(message)s', '< %(message)s'
184
    if debug:
185
        print('Logging location: %s' % logger.get_log_filename())
186
        logger.add_stream_logger('kamaki.clients.send', logging.DEBUG, sfmt)
187
        logger.add_stream_logger('kamaki.clients.recv', logging.DEBUG, rfmt)
188
        logger.add_stream_logger(__name__, logging.DEBUG)
189
    elif verbose:
190
        logger.add_stream_logger('kamaki.clients.send', logging.INFO, sfmt)
191
        logger.add_stream_logger('kamaki.clients.recv', logging.INFO, rfmt)
192
        logger.add_stream_logger(__name__, logging.INFO)
193
    logger.add_stream_logger(__name__, logging.WARNING)
194
    global kloger
195
    kloger = logger.get_logger(__name__)
196

    
197

    
198
def _check_config_version(cnf):
199
    guess = cnf.guess_version()
200
    if exists(cnf.path) and guess < 0.12:
201
        print('Config file format version >= 0.12 is required (%s found)' % (
202
            guess))
203
        print('Configuration file: %s' % cnf.path)
204
        print('Attempting to fix this:')
205
        print('Calculating changes while preserving information')
206
        lost_terms = cnf.rescue_old_file()
207
        print('... DONE')
208
        if lost_terms:
209
            print 'The following information will NOT be preserved:'
210
            print '\t', '\n\t'.join(lost_terms)
211
        print('Kamaki is ready to convert the config file')
212
        stdout.write('Create (overwrite) file %s ? [y/N] ' % cnf.path)
213
        from sys import stdin
214
        reply = stdin.readline()
215
        if reply in ('Y\n', 'y\n'):
216
            cnf.write()
217
            print('... DONE')
218
        else:
219
            print('... ABORTING')
220
            raise CLIError(
221
                'Invalid format for config file %s' % cnf.path,
222
                importance=3, details=[
223
                    'Please, update config file',
224
                    'For automatic conversion, rerun and say Y'])
225

    
226

    
227
def _init_session(arguments, is_non_API=False):
228
    """
229
    :returns: cloud name
230
    """
231
    global _help
232
    _help = arguments['help'].value
233
    global _debug
234
    _debug = arguments['debug'].value
235
    global _verbose
236
    _verbose = arguments['verbose'].value
237
    _cnf = arguments['config']
238

    
239
    _silent = arguments['silent'].value
240
    _setup_logging(_silent, _debug, _verbose)
241

    
242
    if _help or is_non_API:
243
        return None
244

    
245
    _check_config_version(_cnf.value)
246

    
247
    global _colors
248
    _colors = _cnf.value.get('global', 'colors')
249
    if not (stdout.isatty() and _colors == 'on'):
250
        from kamaki.cli.utils import remove_colors
251
        remove_colors()
252

    
253
    cloud = arguments['cloud'].value or _cnf.value.get(
254
        'global', 'default_cloud')
255
    if not cloud:
256
        num_of_clouds = len(_cnf.value.keys('cloud'))
257
        if num_of_clouds == 1:
258
            cloud = _cnf.value.keys('cloud')[0]
259
        elif num_of_clouds > 1:
260
            raise CLIError(
261
                'Found %s clouds but none of them is set as default' % (
262
                    num_of_clouds),
263
                importance=2, details=[
264
                    'Please, choose one of the following cloud names:',
265
                    ', '.join(_cnf.value.keys('cloud')),
266
                    'To see all cloud settings:',
267
                    '  kamaki config get cloud.<cloud name>',
268
                    'To set a default cloud:',
269
                    '  kamaki config set default_cloud <cloud name>',
270
                    'To pick a cloud for the current session, use --cloud:',
271
                    '  kamaki --cloud=<cloud name> ...'])
272
    if not cloud in _cnf.value.keys('cloud'):
273
        raise CLIError(
274
            'No cloud%s is configured' % ((' "%s"' % cloud) if cloud else ''),
275
            importance=3, details=[
276
                'To configure a new cloud "%s", find and set the' % (
277
                    cloud or '<cloud name>'),
278
                'single authentication URL and token:',
279
                '  kamaki config set cloud.%s.url <URL>' % (
280
                    cloud or '<cloud name>'),
281
                '  kamaki config set cloud.%s.token <t0k3n>' % (
282
                    cloud or '<cloud name>')])
283
    auth_args = dict()
284
    for term in ('url', 'token'):
285
        try:
286
            auth_args[term] = _cnf.get_cloud(cloud, term)
287
        except KeyError or IndexError:
288
            auth_args[term] = ''
289
        if not auth_args[term]:
290
            raise CLIError(
291
                'No authentication %s provided for cloud "%s"' % (
292
                    term.upper(), cloud),
293
                importance=3, details=[
294
                    'Set a %s for cloud %s:' % (term.upper(), cloud),
295
                    '  kamaki config set cloud.%s.%s <%s>' % (
296
                        cloud, term, term.upper())])
297
    return cloud
298

    
299

    
300
def init_cached_authenticator(config_argument, cloud, logger):
301
    try:
302
        _cnf = config_argument.value
303
        url = _cnf.get_cloud(cloud, 'url')
304
        tokens = _cnf.get_cloud(cloud, 'token').split()
305
        auth_base, failed = None, []
306
        for token in tokens:
307
            try:
308
                if auth_base:
309
                    auth_base.authenticate(token)
310
                else:
311
                    tmp_base = CachedAstakosClient(url, token)
312
                    from kamaki.cli.commands import _command_init
313
                    fake_cmd = _command_init(dict(config=config_argument))
314
                    fake_cmd.client = auth_base
315
                    fake_cmd._set_log_params()
316
                    tmp_base.authenticate(token)
317
                    auth_base = tmp_base
318
            except ClientError as ce:
319
                if ce.status in (401, ):
320
                    logger.warning(
321
                        'WARNING: Failed to authenticate token %s' % token)
322
                    failed.append(token)
323
                else:
324
                    raise
325
        for token in failed:
326
            r = raw_input(
327
                'Token %s failed to authenticate. Remove it? [y/N]: ' % token)
328
            if r in ('y', 'Y'):
329
                tokens.remove(token)
330
        if set(failed).difference(tokens):
331
            _cnf.set_cloud(cloud, 'token', ' '.join(tokens))
332
            _cnf.write()
333
        if tokens:
334
            return auth_base
335
        logger.warning('WARNING: cloud.%s.token is now empty' % cloud)
336
    except AssertionError as ae:
337
        logger.warning('WARNING: Failed to load authenticator [%s]' % ae)
338
    return None
339

    
340

    
341
def _load_spec_module(spec, arguments, module):
342
    global kloger
343
    if not spec:
344
        return None
345
    pkg = None
346
    for location in cmd_spec_locations:
347
        location += spec if location == '' else '.%s' % spec
348
        try:
349
            kloger.debug('Import %s from %s' % ([module], location))
350
            pkg = __import__(location, fromlist=[module])
351
            kloger.debug('\t...OK')
352
            return pkg
353
        except ImportError as ie:
354
            kloger.debug('\t...Failed')
355
            continue
356
    if not pkg:
357
        msg = 'Loading command group %s failed: %s' % (spec, ie)
358
        msg += '\nHINT: use a text editor to remove all global.*_cli'
359
        msg += '\n\tsettings from the configuration file'
360
        kloger.debug(msg)
361
    return pkg
362

    
363

    
364
def _groups_help(arguments):
365
    global _debug
366
    global kloger
367
    descriptions = {}
368
    acceptable_groups = arguments['config'].groups
369
    for cmd_group, spec in arguments['config'].cli_specs:
370
        pkg = _load_spec_module(spec, arguments, '_commands')
371
        if pkg:
372
            cmds = getattr(pkg, '_commands')
373
            try:
374
                for cmd_tree in cmds:
375
                    if cmd_tree.name in acceptable_groups:
376
                        descriptions[cmd_tree.name] = cmd_tree.description
377
            except TypeError:
378
                if _debug:
379
                    kloger.warning(
380
                        'No cmd description (help) for module %s' % cmd_group)
381
        elif _debug:
382
            kloger.warning('Loading of %s cmd spec failed' % cmd_group)
383
    print('\nOptions:\n - - - -')
384
    print_dict(descriptions)
385

    
386

    
387
def _load_all_commands(cmd_tree, arguments):
388
    _cnf = arguments['config']
389
    for cmd_group, spec in _cnf.cli_specs:
390
        try:
391
            spec_module = _load_spec_module(spec, arguments, '_commands')
392
            spec_commands = getattr(spec_module, '_commands')
393
        except AttributeError:
394
            if _debug:
395
                global kloger
396
                kloger.warning('No valid description for %s' % cmd_group)
397
            continue
398
        for spec_tree in spec_commands:
399
            if spec_tree.name == cmd_group:
400
                cmd_tree.add_tree(spec_tree)
401
                break
402

    
403

    
404
#  Methods to be used by CLI implementations
405

    
406

    
407
def print_subcommands_help(cmd):
408
    printout = {}
409
    for subcmd in cmd.subcommands.values():
410
        spec, sep, print_path = subcmd.path.partition('_')
411
        printout[print_path.replace('_', ' ')] = subcmd.help
412
    if printout:
413
        print('\nOptions:\n - - - -')
414
        print_dict(printout)
415

    
416

    
417
def update_parser_help(parser, cmd):
418
    global _best_match
419
    parser.syntax = parser.syntax.split('<')[0]
420
    parser.syntax += ' '.join(_best_match)
421

    
422
    description = ''
423
    if cmd.is_command:
424
        cls = cmd.cmd_class
425
        parser.syntax += ' ' + cls.syntax
426
        parser.update_arguments(cls().arguments)
427
        description = getattr(cls, 'long_description', '').strip()
428
    else:
429
        parser.syntax += ' <...>'
430
    parser.parser.description = (
431
        cmd.help + ('\n' if description else '')) if cmd.help else description
432

    
433

    
434
def print_error_message(cli_err, out=stderr):
435
    errmsg = '%s' % cli_err
436
    if cli_err.importance == 1:
437
        errmsg = magenta(errmsg)
438
    elif cli_err.importance == 2:
439
        errmsg = yellow(errmsg)
440
    elif cli_err.importance > 2:
441
        errmsg = red(errmsg)
442
    out.write(errmsg)
443
    for errmsg in cli_err.details:
444
        out.write('|  %s\n' % errmsg)
445
        out.flush()
446

    
447

    
448
def exec_cmd(instance, cmd_args, help_method):
449
    try:
450
        return instance.main(*cmd_args)
451
    except TypeError as err:
452
        if err.args and err.args[0].startswith('main()'):
453
            print(magenta('Syntax error'))
454
            if _debug:
455
                raise err
456
            if _verbose:
457
                print(unicode(err))
458
            help_method()
459
        else:
460
            raise
461
    return 1
462

    
463

    
464
def get_command_group(unparsed, arguments):
465
    groups = arguments['config'].groups
466
    for term in unparsed:
467
        if term.startswith('-'):
468
            continue
469
        if term in groups:
470
            unparsed.remove(term)
471
            return term
472
        return None
473
    return None
474

    
475

    
476
def set_command_params(parameters):
477
    """Add a parameters list to a command
478

479
    :param paramters: (list of str) a list of parameters
480
    """
481
    global command
482
    def_params = list(command.func_defaults)
483
    def_params[0] = parameters
484
    command.func_defaults = tuple(def_params)
485

    
486

    
487
#  CLI Choice:
488

    
489
def is_non_API(parser):
490
    nonAPIs = ('history', 'config')
491
    for term in parser.unparsed:
492
        if not term.startswith('-'):
493
            if term in nonAPIs:
494
                return True
495
            return False
496
    return False
497

    
498

    
499
def main(func):
500
    def wrap():
501
        try:
502
            exe = basename(argv[0])
503
            parser = ArgumentParseManager(exe)
504

    
505
            if parser.arguments['version'].value:
506
                exit(0)
507

    
508
            _cnf = parser.arguments['config']
509
            log_file = _cnf.get('global', 'log_file')
510
            if log_file:
511
                logger.set_log_filename(log_file)
512
            global filelog
513
            filelog = logger.add_file_logger(__name__.split('.')[0])
514
            filelog.info('* Initial Call *\n%s\n- - -' % ' '.join(argv))
515

    
516
            from kamaki.cli.utils import suggest_missing
517
            global _colors
518
            exclude = ['ansicolors'] if not _colors == 'on' else []
519
            suggest_missing(exclude=exclude)
520
            func(exe, parser)
521
        except CLIError as err:
522
            print_error_message(err)
523
            if _debug:
524
                raise err
525
            exit(1)
526
        except KeyboardInterrupt:
527
            print('Canceled by user')
528
            exit(1)
529
        except Exception as er:
530
            print('Unknown Error: %s' % er)
531
            if _debug:
532
                raise
533
            exit(1)
534
    return wrap
535

    
536

    
537
@main
538
def run_shell(exe, parser):
539
    parser.arguments['help'].value = False
540
    cloud = _init_session(parser.arguments)
541
    from command_shell import _init_shell
542
    global kloger
543
    _cnf = parser.arguments['config']
544
    auth_base = init_cached_authenticator(_cnf, cloud, kloger)
545
    try:
546
        username, userid = (
547
            auth_base.user_term('name'), auth_base.user_term('id'))
548
    except Exception:
549
        username, userid = '', ''
550
    shell = _init_shell(exe, parser, username, userid)
551
    _load_all_commands(shell.cmd_tree, parser.arguments)
552
    shell.run(auth_base, cloud, parser)
553

    
554

    
555
@main
556
def run_one_cmd(exe, parser):
557
    cloud = _init_session(parser.arguments, is_non_API(parser))
558
    if parser.unparsed:
559
        global _history
560
        cnf = parser.arguments['config']
561
        try:
562
            token = cnf.get_cloud(cloud, 'token').split()[0]
563
        except Exception:
564
            token = None
565
        _history = History(cnf.get('global', 'history_file'), token=token)
566
        _history.limit = cnf.get('global', 'history_limit')
567
        _history.add(' '.join([exe] + argv[1:]))
568
        from kamaki.cli import one_command
569
        one_command.run(cloud, parser, _help)
570
    else:
571
        parser.print_help()
572
        _groups_help(parser.arguments)
573
        print('kamaki-shell: An interactive command line shell')