Synnefo » ./kamaki

# or implied, of GRNET S.A.command

from kamaki.cli.logger import get_logger

log = get_logger(__name__)

            arguments.update(self.oo_arguments)

        if isinstance(self, _optional_json):

            arguments.update(self.oj_arguments)

        try:

            arguments.update(self.wait_arguments)

        except AttributeError:

            print_json(output)

        else:

            print_method(output, **print_method_kwargs)

from kamaki.cli.argument import FlagArgument, ValueArgument, KeyValueArgument

from kamaki.cli.argument import ProgressBarArgument, DateArgument, IntArgument

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

from base64 import b64encode

from os.path import exists

@command(server_cmds)

    """List Virtual Machines accessible by user"""

    PERMANENTS = ('id', 'name')

            'output results in pages (-n to set items per page, default 10)',

            '--more'),

        enum=FlagArgument('Enumerate results', '--enumerate'),

        flavor_id=ValueArgument('filter by flavor id', ('--flavor-id')),

        image_id=ValueArgument('filter by image id', ('--image-id')),

        meta=KeyValueArgument('filter by metadata key=values', ('--metadata')),

            ('--metadata-like')),

    )

    def _add_user_name(self, servers):

        uuids = self._uuids2usernames(list(set(

                [srv['user_id'] for srv in servers] +

            srv['tenant_id'] += ' (%s)' % uuids[srv['tenant_id']]

        return servers

        iid = self['image_id']

        new_servers = []

        for srv in servers:

                new_servers.append(srv)

        return new_servers

        fid = self['flavor_id']

        new_servers = []

        for srv in servers:

                new_servers.append(srv)

        return new_servers

        new_servers = []

        for srv in servers:

            if not 'metadata' in srv:

        detail = self['detail'] or withimage or withflavor or withmeta

        servers = self.client.list_servers(detail, self['since'])

        if withimage:

        if withflavor:

        if withmeta:

        if self['detail'] and not self['json_output']:

            servers = self._add_user_name(servers)

@command(flavor_cmds)

    """List available hardware flavors"""

    arguments = dict(

    @errors.cyclades.connection

    def _run(self):

        flavors = self.client.list_flavors(self['detail'])

        if not (self['detail'] or self['json_output']):

            remove_from_items(flavors, 'links')

        pg_size = 10 if self['more'] and not self['limit'] else self['limit']

@command(network_cmds)

    """List networks"""

    arguments = dict(

    @errors.cyclades.connection

    def _run(self):

        networks = self.client.list_networks(self['detail'])

        if not (self['detail'] or self['json_output']):

            remove_from_items(networks, 'links')

        kwargs = dict(with_enumeration=self['enum'])

from kamaki.cli.commands.cyclades import _init_cyclades

from kamaki.cli.errors import raiseCLIError, CLIBaseUrlError

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

image_cmds = CommandTree(

@command(image_cmds)

    """List images accessible by user"""

    PERMANENTS = (

            'filter by container format',

            '--container-format'),

        disk_format=ValueArgument('filter by disk format', '--disk-format'),

        size_min=IntArgument('filter by minimum size', '--size-min'),

        size_max=IntArgument('filter by maximum size', '--size-max'),

        status=ValueArgument('filter by status', '--status'),

            ('--property-like')),

    )

        ouuid = self['owner'] or self._username2uuid(self['owner_name'])

        return filter_dicts_by_dict(images, dict(owner=ouuid))

    def _add_owner_name(self, images):

        uuids = self._uuids2usernames(

            list(set([img['owner'] for img in images])))

            img['owner'] += ' (%s)' % uuids[img['owner']]

        return images

        new_images = []

        for img in images:

            props = [dict(img['properties'])]

        images = self.client.list_public(detail, filters, order)

        if self['owner'] or self['owner_name']:

        if self['prop'] or self['prop_like']:

        if self['detail'] and not self['json_output']:

            images = self._add_owner_name(images)

@command(image_cmds)

    """List images"""

    PERMANENTS = ('id', 'name')

            'output results in pages (-n to set items per page, default 10)',

            '--more'),

        enum=FlagArgument('Enumerate results', '--enumerate'),

        user_id=ValueArgument('filter by user_id', '--user-id'),

        user_name=ValueArgument('filter by username', '--user-name'),

        meta=KeyValueArgument(

            ('--metadata-like'))

    )

    def _filter_by_metadata(self, images):

        new_images = []

        for img in images:

        withuser = bool(self['user_id'] or self['user_name'])

        detail = self['detail'] or withmeta or withuser

        images = self.client.list_images(detail)

        if withuser:

            images = self._filter_by_user(images)

        if withmeta:

from kamaki.cli.argument import ProgressBarArgument

from kamaki.cli.commands import _command_init, errors

from kamaki.cli.commands import addLogSettings, DontRaiseKeyError

from kamaki.clients.pithos import PithosClient, ClientError

from kamaki.clients.astakos import AstakosClient

@command(pithos_cmds)

    """List containers, object trees or objects in a directory

    Use with:

    1 no parameters : containers in current account

                if_unmodified_since=self['if_unmodified_since'],

                until=self['until'],

                show_only_shared=self['shared'])

        else:

            r = self.client.container_get(

                limit=False if self['more'] else self['limit'],

                marker=self['marker'],

                until=self['until'],

                meta=self['meta'],

                show_only_shared=self['shared'])

    def main(self, container____path__=None):

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