Synnefo » ./kamaki

def _check_config_version(cnf):

    guess = cnf.guess_version()

    if guess < 3.0:

            cnf.path))

        lost_terms = cnf.rescue_old_file()

        print('... DONE')

        stdout.write('Overwrite file %s ? [Y, y] ' % cnf.path)

        from sys import stdin

        reply = stdin.readline()

            print('... ABORTING')

            raise CLIError(

                'Invalid format for config file %s' % cnf.path,

    global _help

    _help = arguments['help'].value

    global _debug

    _verbose = arguments['verbose'].value

    _cnf = arguments['config']

    _check_config_version(_cnf.value)

    global _colors

    if not (stdout.isatty() and _colors == 'on'):

        from kamaki.cli.utils import remove_colors

        remove_colors()

    _silent = arguments['silent'].value

    _setup_logging(_silent, _debug, _verbose, _include)

    from kamaki.clients.astakos import AstakosClient as AuthCachedClient

    try:

    except AssertionError as ae:

        return None

def _load_spec_module(spec, arguments, module):

    if not spec:

        return None

    pkg = None

def _load_all_commands(cmd_tree, arguments):

    _cnf = arguments['config']

    for cmd_group, spec in _cnf.get_cli_specs():

        try:

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

def run_one_cmd(exe_string, parser, auth_base):

    global _history

    _history = History(

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

    from kamaki.cli import one_command

    one_command.run(auth_base, parser, _help)

    shell.run(auth_base, parser)

def main():

    try:

        exe = basename(argv[0])

        if parser.arguments['version'].value:

            exit(0)

        if log_file:

            logger.set_log_filename(log_file)

        global filelog

        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):

    def get_cli_specs(self):

_config_arg = ConfigArgument(

class CmdLineConfigArgument(Argument):

        self.auth_base = auth_base

        self._parser = parser

        self._history = History(

        if path:

            cmd = self.cmd_tree.get_command(path)

            intro = cmd.path.replace('_', ' ')

from kamaki.cli.logger import get_logger

from kamaki.cli.utils import print_json, print_items

from kamaki.cli.argument import FlagArgument

log = get_logger(__name__)

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:

            self.client.LOG_TOKEN, self.client.LOG_DATA = (

        except Exception as e:

            log.warning('Failed to read custom log settings:'

                '%s\n defaults for token and data logging are off' % e)

    def _update_max_threads(self):

        try:

            assert max_threads > 0

            self.client.MAX_THREADS = max_threads

        except Exception as e:

        #  'livetest_cli': 'livetest',

        #  'astakos_cli': 'snf-astakos'

    },

    {

        'default': {

            'url': '',

                return 2.0

        log.warning('........ nope')

        log.warning('Config file heuristic 2: at least 1 remote section ?')

                log.warning('... found remote "%s"' % r)

                return 3.0

        log.warning('........ nope')

        :raises KeyError: if remote or remote's option does not exist

        """

        if not r:

            raise KeyError('Remote "%s" does not exist' % remote)

        return r[option]

    def set_remote(self, remote, option, value):

        try:

        except KeyError:

            pass

        d[option] = value

    def _load_defaults(self):

        for section, options in DEFAULTS.items():

        self._overrides[section][option] = value

    def write(self):

            for k, v in d.items():

                self.set('remote "%s"' % r, k, v)

        with open(self.path, 'w') as f:

            os.chmod(self.path, 0600)

            self.importance = 0

class CLIBaseUrlError(CLIError):

    def __init__(self, message='', details=[], importance=2, service=None):

        message = message or 'No url for %s' % service.lower()

        details = details or [

            'Two options to resolve this:',

            'A. (recommended) Let kamaki discover the endpoint URLs for all',

            'B. (advanced users) Explicitly set a valid %s endpoint URL' % (

                service.upper()),

            'make that work',

        super(CLIBaseUrlError, self).__init__(message, details, importance)

    return None

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

    if not group:

        parser.parser.print_help()

    global _best_match

    _best_match = []

    spec_module = _load_spec_module(group_spec, parser.arguments, '_commands')

    if spec_module is None:

        raise CLIUnknownCommand(

        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 kamaki.cli.errors import raiseCLIError

        active=False,

        url='#install-ansicolors-progress',

try:

    from colors import magenta, red, yellow, bold