Synnefo » ./kamaki

        remove_colors()

    _silent = arguments['silent'].value

    _setup_logging(_silent, _debug, _verbose, _include)

def _load_spec_module(spec, arguments, module):

        return None

    pkg = None

    for location in cmd_spec_locations:

        try:

            pkg = __import__(location, fromlist=[module])

            return pkg

            continue

    return pkg

    global _debug

    global kloger

    descriptions = {}

        pkg = _load_spec_module(spec, arguments, '_commands')

        if pkg:

            try:

                for cmd in cmds:

                    descriptions[cmd.name] = cmd.description

            except TypeError:

                if _debug:

        elif _debug:

    print('\nOptions:\n - - - -')

    print_dict(descriptions)

def _load_all_commands(cmd_tree, arguments):

    _cnf = arguments['config']

        try:

            spec_module = _load_spec_module(spec, arguments, '_commands')

            spec_commands = getattr(spec_module, '_commands')

        except AttributeError:

            if _debug:

                global kloger

            continue

        for spec_tree in spec_commands:

                cmd_tree.add_tree(spec_tree)

                break

        errmsg = red(errmsg)

    stdout.write(errmsg)

    for errmsg in cli_err.details:

def exec_cmd(instance, cmd_args, help_method):

#  CLI Choice:

    global _history

    _history = History(

        parser.arguments['config'].get('history', 'file'))

    _history.add(' '.join([exe_string] + argv[1:]))

    from kamaki.cli import one_command

    from command_shell import _init_shell

    shell = _init_shell(exe_string, parser)

    _load_all_commands(shell.cmd_tree, parser.arguments)

def main():

        filelog = logger.add_file_logger(__name__.split('.')[0])

        filelog.info('* Initial Call *\n%s\n- - -' % ' '.join(argv))

        from kamaki.cli.utils import suggest_missing

        suggest_missing()

        if parser.unparsed:

        elif _help:

            parser.parser.print_help()

            _groups_help(parser.arguments)

        else:

    except CLIError as err:

        print_error_message(err)

        if _debug:

        return self.value.get(group, term)

    def get_groups(self):

_config_arg = ConfigArgument(

    1, 'Path to configuration file',

    _context_stack = []

    _prompt_stack = []

    _parser = None

    undoc_header = 'interactive shell commands:'

                    if subcmd.path == 'history_run':

                        instance = cls(

                            dict(cmd_parser.arguments),

                    else:

                    cmd_parser.update_arguments(instance.arguments)

                    cmd_parser.arguments = instance.arguments

                    cmd_parser.syntax = '%s %s' % (

                        subcmd.path.replace('_', ' '), cls.syntax)

        hdr = tmp_partition[0].strip()

        return '%s commands:' % hdr

        self._parser = parser

        self._history = History(

            parser.arguments['config'].get('history', 'file'))

class _command_init(object):

        if hasattr(self, 'arguments'):

            arguments.update(self.arguments)

        if isinstance(self, _optional_output_cmd):

            self.config = self['config']

        except KeyError:

            pass

    def _set_log_params(self):

        try:

# or implied, of GRNET S.A.command

from kamaki.cli import command

from kamaki.cli.commands import _command_init, errors, _optional_json

from kamaki.cli.command_tree import CommandTree

    @errors.generic.all

    @errors.user.load

    def _run(self):

        self._set_log_params()

        self._update_max_threads()

    @errors.user.authenticate

    def _run(self, custom_token=None):

        super(self.__class__, self)._run()

    def main(self, custom_token=None):

        self._run(custom_token)

about_options = '\nAbout options:\

    \n. syntax: [group.]option\

    \n. special case: <option> is equivalent to global.<option>\

    \n. configuration file syntax:\

    \n.   [group]\

    def _run(self, service='compute'):

        token = self.config.get(service, 'token')\

            or self.config.get('global', 'token')

        self.client = CycladesClient(base_url=base_url, token=token)

        self._set_log_params()

        self._update_max_threads()

        return _raise

    @classmethod

        def _raise(self, *args, **kwargs):

            try:

                foo(self, *args, **kwargs)

                        '  to get current token: /config get [server.]token'])

                elif ce.status in range(-12, 200) + [302, 401, 403, 500]:

                    raiseCLIError(ce, importance=3, details=[

                elif ce.status == 404 and 'kamakihttpresponse' in ce_msg:

                    client = getattr(self, 'client', None)

                    if not client:

                    url = getattr(client, 'base_url', '<empty>')

                    msg = 'Invalid service url %s' % url

                    raiseCLIError(ce, msg, details=[

                raise

        return _raise

    _token_details = [

        'To check default token: /config get token',

        'If set/update a token:',

    @classmethod

    def load(this, foo):

                kloger.warning(

                    'No permanent token (try: kamaki config set token <tkn>)')

            if not getattr(client, 'base_url', False):

                raise CLIError(msg, importance=3, details=[

            return r

        return _raise

    @classmethod

    def connection(this, foo):

    @classmethod

    def date(this, foo):

    @classmethod

    def connection(this, foo):

    @classmethod

    def id(this, foo):

    @classmethod

    def connection(this, foo):

    @classmethod

    def account(this, foo):

    _cmd_tree = None

        super(self.__class__, self).__init__(arguments)

        self._cmd_tree = cmd_tree

        token = self.config.get('image', 'token')\

            or self.config.get('compute', 'token')\

            or self.config.get('global', 'token')

        base_url = self.config.get('image', 'url')\

            or self.config.get('compute', 'url')\

            or self.config.get('global', 'url')

    def _get_pithos_client(self, container):

        if self['no_metafile_upload']:

            return None

        ptoken = self.client.token

        return PithosClient(purl, ptoken, self._get_uuid(), container)

    def _run(self):

        self.token = self.config.get('file', 'token')\

            or self.config.get('global', 'token')

        self._set_account()

        self.container = self.config.get('file', 'container')\

            or self.config.get('global', 'container')

        self._run()

    def _set_account(self):

class _file_account_command(_pithos_init):

    """Base class for account level storage commands"""

        self['account'] = ValueArgument(

            'Set user account (not permanent)',

            ('-A', '--account'))

    container = None

    path = None

        self['container'] = ValueArgument(

            'Set container to work with (temporary)',

            ('-C', '--container'))

        suffix_replace=ValueArgument('', '--suffix-to-replace', default=''),

    )

        self.arguments.update(arguments)

    def _run(self, source_container___path, path_is_optional=False):

        super(_source_destination_command, self)._run(

            ('-R', '--recursive'))

    )

        self['delimiter'] = DelimiterArgument(

            self,

            parsed_name='--delimiter',

class _astakos_init(_command_init):

        self['token'] = ValueArgument('Custom token', '--token')

    @errors.generic.all

            or self.config.get('astakos', 'token')\

            or self.config.get('user', 'token')\

            or self.config.get('global', 'token')

        self.client = AstakosClient(base_url, logger=log)

        self._set_log_params()

        self._update_max_threads()

            for option, val in options.items():

                self.set(section, option, val)

    def reload(self):

        self = self.__init__(self.path)

    def get(self, section, option):

        value = self._overrides.get(section, {}).get(option)

        if value is not None:

        except NoSectionError:

            pass

    def items(self, section, include_defaults=True):

        return d.items()

    def override(self, section, option, value):

    return None

    group = get_command_group(list(parser.unparsed), parser.arguments)

    if not group:

        parser.parser.print_help()

    global _best_match

    _best_match = []

    if spec_module is None:

        raise CLIUnknownCommand(

            'Could not find specs for %s commands' % group,

        exit(0)

    cls = cmd.get_class()

    parser.update_arguments(executable.arguments)

    #parsed, unparsed = parse_known_args(parser, executable.arguments)

    for term in _best_match:

from logging import getLogger

class AstakosClient(Client):

    """Synnefo Astakos API client"""

    def term(self, key, token=None):

        """Get (cached) term, from user credentials"""

        return self.user_info(token).get(key, None)