Synnefo » ./kamaki

def _init_session(arguments, is_non_API=False):

    """

    """

    global _help

    _help = arguments['help'].value

        return None, None

    cloud = arguments['cloud'].value or 'default'

        raise CLIError(

            importance=3, details=[

                'single authentication URL and token:',

    auth_args = dict()

    for term in ('url', 'token'):

        if not auth_args[term]:

            raise CLIError(

                'No authentication %s provided for %s cloud' % (term, cloud),

                importance=3, details=[

                    'Get and set a %s for %s cloud:' % (term, cloud),

                ])

    from kamaki.clients.astakos import AstakosClient as AuthCachedClient

    def get_global(self, option):

        return self.value.get_global(option)

_config_arg = ConfigArgument(

    1, 'Path to configuration file', ('-c', '--config'))

_arguments = dict(

    config=_config_arg,

    help=Argument(0, 'Show help message', ('-h', '--help')),

    debug=FlagArgument('Include debug output', ('-d', '--debug')),

    include=FlagArgument(

    @DontRaiseKeyError

    def _custom_url(self, service):

    @DontRaiseKeyError

    def _custom_token(self, service):

    @DontRaiseKeyError

    def _custom_type(self, service):

    @DontRaiseKeyError

    def _custom_version(self, service):

    def _set_log_params(self):

        try:

            base_url = self._custom_url('astakos')

            if base_url:

                token = self._custom_token('astakos')\

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

                return

        else:

    """Authenticate a user

    Get user information (e.g. unique account name) from token

    Token should be set in settings:

    Token can also be provided as a parameter

    """

    @staticmethod

    \n.   [group]\

    \n.   option=value\

    \n.   (more options can be set per group)\

    \n. E.g. for a cloud "demo":\

    \n.   url = <http://single/authentication/url/for/demo/site>\

    \n.   token = <auth_token_from_demo_site>\

@command(config_cmds)

        for section in sorted(self.config.sections()):

            items = self.config.items(section)

            for key, val in sorted(items):

                    prefix = '%s.%s' % (section, key)

                    for k, v in val.items():

                        print('%s..%s = %s' % (prefix, k, v))

            match = False

            for k in self.config.keys(key):

                match = True

                    stdout.write('%s.%s =' % (option, k))

                self._run('%s.%s' % (option, k))

            if match:

                return

            section = 'global'

        get, section = (

                section.startswith(prefix)) else (self.config.get, section)

        value = get(section, key)

        if isinstance(value, dict):

    @errors.generic.all

    def _run(self, option, value):

        section, sep, key = option.rpartition('.')

        if section.startswith(prefix):

            raise CLISyntaxError(

                'Invalid syntax for cloud definition', importance=2, details=[

                    'set the cloud\'s authentication url and token:',

        else:

            section = section or 'global'

            self.config.set(section, key, value)

    def _run(self, option):

        section, sep, key = option.rpartition('.')

        section = section or 'global'

        if section.startswith(prefix):

            try:

            except KeyError:

                raise CLIError('Field %s does not exist' % option)

        else:

about_authentication = '\nUser Authentication:\

    \n* to check authentication: /user authenticate\

howto_personality = [

    'Defines a file to be injected to VMs personality.',

            if base_url:

                token = self._custom_token(service)\

                    or self._custom_token('cyclades')\

                self.client = CycladesClient(

                    base_url=base_url, token=token)

                return

from kamaki.cli.utils import format_size

CLOUDNAME = [

class generic(object):

                        'Make sure a valid token is provided:',

                        '  to check if token is valid: /user authenticate',

                        '  to set token:',

                        '  to get current token:',

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

                    raiseCLIError(ce, importance=3, details=[

                        'Check if service is up'])

                    raiseCLIError(ce, msg, details=[

                        'Check if authentication url is correct',

                        '  check current url:',

                        '  set new auth. url:',

                raise

        return _raise

class user(object):

    _token_details = [

        'If set/update a token:',

        '*  (temporary):  re-run with <token> parameter'] + CLOUDNAME

    @classmethod

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

                kloger.warning(

                    'No permanent token (try:'

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

                msg = 'Missing synnefo authentication URL'

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

                    'Check if authentication url is correct',

                        '  check current url:',

                        '  set new auth. url:',

            return r

        return _raise

            if img_url:

                token = self._custom_token('image')\

                    or self._custom_token('plankton')\

                self.client = ImageClient(base_url=img_url, token=token)

                return

        if getattr(self, 'auth_base', False):

    @DontRaiseKeyError

    def _custom_container(self):

    @DontRaiseKeyError

    def _custom_uuid(self):

    def _set_account(self):

        self.account = self._custom_uuid()

    def _run(self):

        self.cloud = self.cloud if self.cloud else 'default'

        self.token = self['token'] or self._custom_token('astakos')\

        if getattr(self, 'auth_base', False):

            astakos_endpoints = self.auth_base.get_service_endpoints(

                self._custom_type('astakos') or 'identity',

    """Authenticate a user

    Get user information (e.g. unique account name) from token

    Token should be set in settings:

    Token can also be provided as a parameter

    """

    arguments = dict(

from re import match

from kamaki.cli.errors import CLISyntaxError

try:

    from collections import OrderedDict

# Name of a shell variable to bypass the CONFIG_PATH value

CONFIG_ENV = 'KAMAKI_CONFIG'

DEFAULTS = {

    'global': {

        'colors': 'off',

        'log_file': os.path.expanduser('~/.kamaki.log'),

        'log_token': 'off',

        #  'livetest_cli': 'livetest',

        #  'astakos_cli': 'snf-astakos'

    },

    {

    }

}

        self.read(self.path)

        for section in self.sections():

            if r:

                for k, v in self.items(section):

                self.remove_section(section)

    @staticmethod

        return matcher.groups()[0] if matcher else None

    def rescue_old_file(self):

            user=dict(serv='astakos', cmd='user'),

        )

        for s in self.sections():

            if s in ('global'):

                # global.url, global.token -->

                for term in set(self.keys(s)).difference(global_terms):

                    if term not in ('url', 'token'):

                        lost_terms.append('%s.%s = %s' % (

                        self.remove_option(s, term)

                        continue

                    gval = self.get(s, term)

                    if gval and cval and (

                        gval.lower().strip('/') != cval.lower().strip('/')):

                            raise CLISyntaxError(

                                'Conflicting values for default %s' % term,

                                importance=2, details=[

                                    ' global.%s:  %s' % (term, gval),

                                    'Please remove one of them manually:',

                                    ' /config delete global.%s' % term,

                                    ' or'

                                    'and try again'])

                    elif gval:

                            s, term, term))

                    self.remove_option(s, term)

            # translation for <service> or <command> settings

            # <service> or <command group> settings --> translation --> global

                    if v and k in ('cli',):

                        print('... rescue %s.%s => global.%s_cli' % (

                            s, k, trn['cmd']))

                                    s, k, k))

                        lost_terms.append('%s.%s = %s' % (s, k, v))

                self.remove_section(s)

        #  self.pretty_print()

                    print '\t', k, '=>', v

    def guess_version(self):

        checker = Config(self.path, with_defaults=False)

        sections = checker.sections()

        if 'global' in sections:

            if checker.get('global', 'url') or checker.get('global', 'token'):

                log.warning('..... config file has an old global section')

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

        log.warning('All heuristics failed, cannot decide')

        return 0.0

        """

        :returns: (str) the value assigned on this option

        """

        if not r:

        return r[option]

    def get_global(self, option):

        return self.get('global', option)

        try:

        except KeyError:

            d = dict()

        d[option] = value

    def set_global(self, option, value):

        self.set('global', option, value)

    def get(self, section, option):

        """

        :param option: (str)

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

        if value is not None:

            return value

        try:

            return RawConfigParser.get(self, section, option)

        except (NoSectionError, NoOptionError):

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

        """

        :param option: (str)

        :param value: str

        """

        if section not in RawConfigParser.sections(self):

            self.add_section(section)

        RawConfigParser.set(self, section, option, value)

        except NoSectionError:

            pass

        if isinstance(d, dict):

            d.pop(option)

        self._overrides[section][option] = value

    def write(self):

            for k, v in d.items():

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

            os.chmod(self.path, 0600)

            'Two options to resolve this:',

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

            'services by setting a single Authentication URL and token:',

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

                service.upper()),

            'Note: url option has a higher priority, so delete it to',

            'make that work',

                service, service.upper())]

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

        exit(0)

    cls = cmd.get_class()

    parser.update_arguments(executable.arguments)

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

    for term in _best_match: