__init__.py

#!/usr/bin/env python

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

from __future__ import print_function

import gevent.monkey
#Monkey-patch everything for gevent early on
gevent.monkey.patch_all()

import logging

from inspect import getargspec
from argparse import ArgumentParser, ArgumentError
from base64 import b64encode
from os.path import abspath, basename, exists
from sys import exit, stdout, stderr, argv

try:
    from collections import OrderedDict
except ImportError:
    from ordereddict import OrderedDict

#from kamaki import clients
from .errors import CLIError, CLISyntaxError, CLICmdIncompleteError, CLICmdSpecError
from .config import Config #TO BE REMOVED
from .utils import bold, magenta, red, yellow, print_list, print_dict
from .command_tree import CommandTree
from argument import _arguments, parse_known_args

cmd_spec_locations = [
    'kamaki.cli.commands',
    'kamaki.commands',
    'kamaki.cli',
    'kamaki',
    '']
_commands = CommandTree(name='kamaki', description='A command line tool for poking clouds')

#If empty, all commands are loaded, if not empty, only commands in this list
#e.g. [store, lele, list, lolo] is good to load store_list but not list_store
#First arg should always refer to a group
candidate_command_terms = []
allow_no_commands = False
allow_all_commands = False
allow_subclass_signatures = False

def _allow_class_in_cmd_tree(cls):
    global allow_all_commands
    if allow_all_commands:
        return True
    global allow_no_commands 
    if allow_no_commands:
        return False

    term_list = cls.__name__.split('_')
    global candidate_command_terms
    index = 0
    for term in candidate_command_terms:
        try:
            index += 1 if term_list[index] == term else 0
        except IndexError: #Whole term list matched!
            return True
    if allow_subclass_signatures:
        if index == len(candidate_command_terms) and len(term_list) > index:
            try: #is subterm already in _commands?
                _commands.get_command('_'.join(term_list[:index+1]))
            except KeyError: #No, so it must be placed there
                return True
        return False

    return True if index == len(term_list) else False

def command():
    """Class decorator that registers a class as a CLI command"""

    def decorator(cls):
        """Any class with name of the form cmd1_cmd2_cmd3_... is accepted"""

        if not _allow_class_in_cmd_tree(cls):
            return cls

        cls.description, sep, cls.long_description = cls.__doc__.partition('\n')

        # Generate a syntax string based on main's arguments
        spec = getargspec(cls.main.im_func)
        args = spec.args[1:]
        n = len(args) - len(spec.defaults or ())
        required = ' '.join('<%s>' % x.replace('____', '[:').replace('___', ':').replace('__',']').\
            replace('_', ' ') for x in args[:n])
        optional = ' '.join('[%s]' % x.replace('____', '[:').replace('___', ':').replace('__', ']').\
            replace('_', ' ') for x in args[n:])
        cls.syntax = ' '.join(x for x in [required, optional] if x)
        if spec.varargs:
            cls.syntax += ' <%s ...>' % spec.varargs

        #store each term, one by one, first
        _commands.add_command(cls.__name__, cls.description, cls)
        return cls
    return decorator

def _update_parser(parser, arguments):
    for name, argument in arguments.items():
        try:
            argument.update_parser(parser, name)
        except ArgumentError:
            pass

def _init_parser(exe):
    parser = ArgumentParser(add_help=False)
    parser.prog='%s <cmd_group> [<cmd_subbroup> ...] <cmd>'%exe
    _update_parser(parser, _arguments)
    return parser

def _print_error_message(cli_err):
    errmsg = unicode(cli_err) + (' (%s)'%cli_err.status if cli_err.status else ' ')
    if cli_err.importance == 1:
        errmsg = magenta(errmsg)
    elif cli_err.importance == 2:
        errmsg = yellow(errmsg)
    elif cli_err.importance > 2:
        errmsg = red(errmsg)
    stdout.write(errmsg)
    if cli_err.details is not None and len(cli_err.details) > 0:
        print(': %s'%cli_err.details)
    else:
        print()

def get_command_group(unparsed):
    groups = _arguments['config'].get_groups()
    for grp_candidate in unparsed:
        if grp_candidate in groups:
            unparsed.remove(grp_candidate)
            return grp_candidate
    return None

def load_command(group, unparsed, reload_package=False):
    global candidate_command_terms
    candidate_command_terms = [group] + unparsed
    pkg = load_group_package(group, reload_package)

    #From all possible parsed commands, chose the first match in user string
    final_cmd = _commands.get_command(group)
    for term in unparsed:
        cmd = final_cmd.get_subcmd(term)
        if cmd is not None:
            final_cmd = cmd
            unparsed.remove(cmd.name)
    return final_cmd

def shallow_load():
    """Load only group names and descriptions"""
    global allow_no_commands 
    allow_no_commands = True#load only descriptions
    for grp in _arguments['config'].get_groups():
        load_group_package(grp)
    allow_no_commands = False

def load_group_package(group, reload_package=False):
    spec_pkg = _arguments['config'].value.get(group, 'cli')
    for location in cmd_spec_locations:
        location += spec_pkg if location == '' else ('.'+spec_pkg)
        try:
            package = __import__(location, fromlist=['API_DESCRIPTION'])
        except ImportError:
            continue
        if reload_package:
            reload(package)
        for grp, descr in package.API_DESCRIPTION.items():
            _commands.add_command(grp, descr)
        return package
    raise CLICmdSpecError(details='Cmd Spec Package %s load failed'%spec_pkg)

def print_commands(prefix=None, full_depth=False):
    cmd_list = _commands.get_groups() if prefix is None else _commands.get_subcommands(prefix)
    cmds = {}
    for subcmd in cmd_list:
        if subcmd.sublen() > 0:
            sublen_str = '( %s more terms ... )'%subcmd.sublen()
            cmds[subcmd.name] = [subcmd.help, sublen_str] if subcmd.has_description else subcmd_str
        else:
            cmds[subcmd.name] = subcmd.help
    if len(cmds) > 0:
        print('\nOptions:')
        print_dict(cmds, ident=12)
    if full_depth:
        _commands.pretty_print()

def one_command():
    _debug = False
    _help = False
    _verbose = False
    try:
        exe = basename(argv[0])
        parser = _init_parser(exe)
        parsed, unparsed = parse_known_args(parser)
        _debug = _arguments['debug'].value
        _help = _arguments['help'].value
        _verbose = _arguments['verbose'].value
        if _arguments['version'].value:
            exit(0)

        group = get_command_group(unparsed)
        if group is None:
            parser.print_help()
            shallow_load()
            print_commands(full_depth=_verbose)
            exit(0)

        cmd = load_command(group, unparsed)
        if _help or not cmd.is_command:
            if cmd.has_description:
                parser.description = cmd.help 
            else:
                try:
                    parser.description = _commands.get_closest_ancestor_command(cmd.path).help
                except KeyError:
                    parser.description = ' '
            parser.prog = '%s %s '%(exe, cmd.path.replace('_', ' '))
            if cmd.is_command:
                cli = cmd.get_class()
                parser.prog += cli.syntax
                _update_parser(parser, cli().arguments)
            else:
                parser.prog += '[...]'
            parser.print_help()

            #Shuuuut, we now have to load one more level just to see what is missing
            global allow_subclass_signatures 
            allow_subclass_signatures = True
            load_command(group, cmd.path.split('_')[1:], reload_package=True)

            print_commands(cmd.path, full_depth=_verbose)
            exit(0)

        cli = cmd.get_class()
        executable = cli(_arguments)
        _update_parser(parser, executable.arguments)
        parser.prog = '%s %s %s'%(exe, cmd.path.replace('_', ' '), cli.syntax)
        parsed, new_unparsed = parse_known_args(parser)
        unparsed = [term for term in unparsed if term in new_unparsed]
        try:
            ret = executable.main(*unparsed)
            exit(ret)
        except TypeError as e:
            if e.args and e.args[0].startswith('main()'):
                parser.print_help()
                exit(1)
            else:
                raise
    except CLIError as err:
        if _debug:
            raise
        _print_error_message(err)
        exit(1)