Synnefo » ./kamaki

# 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.command

API_DESCRIPTION = {'image':'Compute/Cyclades or Glance API image commands'}

from kamaki.cli import command

from kamaki.cli.errors import raiseCLIError

from kamaki.cli.utils import print_dict, print_items, bold

from kamaki.clients.image import ImageClient, ClientError

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

from kamaki.cli.commands.cyclades_cli import _init_cyclades

from kamaki.cli.commands import _command_init

class _init_image(_command_init):

    def main(self):

        try:

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

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

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

        except ClientError as err:

            raiseCLIError(err)

@command()

class image_public(_init_image):

    """List public images"""

    def __init__(self, arguments={}):

        super(image_public, self).__init__(arguments)

        self.arguments['detail'] = FlagArgument('show detailed output', '-l')

        self.arguments['container_format'] = ValueArgument('filter by container format',

            '--container-format')

        self.arguments['disk_format'] = ValueArgument('filter by disk format', '--disk-format')

        self.arguments['name'] = ValueArgument('filter by name', '--name')

        self.arguments['size_min'] = IntArgument('filter by minimum size', '--size-min')

        self.arguments['size_max'] = IntArgument('filter by maximum size', '--size-max')

        self.arguments['status'] = ValueArgument('filter by status', '--status')

        self.arguments['order'] = ValueArgument('order by FIELD (use a - prefix to reverse order)',

            '--order', default='')

    def main(self):

        super(self.__class__, self).main()

        filters = {}

        for arg in ('container_format', 'disk_format', 'name', 'size_min', 'size_max', 'status'):

            val = self.get_argument(arg)

            if val is not None:

                filters[arg] = val

        order = self.get_argument('order')

        try:

            images = self.client.list_public(self.get_argument('detail'), filters=filters,

                order=order)

        except ClientError as err:

            raiseCLIError(err)

        print_items(images, title=('name',))

@command()

class image_meta(_init_image):

    """Get image metadata"""

    def main(self, image_id):

        super(self.__class__, self).main()

        try:

            image = self.client.get_meta(image_id)

        except ClientError as err:

            raiseCLIError(err)

        print_dict(image)

@command()

class image_register(_init_image):

    """Register an image"""

    def __init__(self, arguments={}):

        super(image_register, self).__init__(arguments)

        self.arguments['checksum'] = ValueArgument('set image checksum', '--checksum')

        self.arguments['container_format'] = ValueArgument('set container format',

            '--container-format')

        self.arguments['disk_format'] = ValueArgument('set disk format', '--disk-format')

        self.arguments['id'] = ValueArgument('set image ID', '--id')

        self.arguments['owner'] = ValueArgument('set image owner (admin only)', '--owner')

        self.arguments['properties'] = KeyValueArgument(parsed_name='--properties',

            help = 'add properties in the form "key1=val1 key2=val2 ..."')

        self.arguments['is_public'] = FlagArgument('mark image as public', '--public')

        self.arguments['size'] = IntArgument('set image size', '--size')

    def main(self, name, location):

        super(self.__class__, self).main()

        if not location.startswith('pithos://'):

            account = self.config.get('store', 'account') \

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

            if account[-1] == '/':

                account = account[:-1]

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

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

            location = 'pithos://%s/%s'%(account, location) \

                if container is None or len(container) == 0 \

                else 'pithos://%s/%s/%s' % (account, container, location)

        params = {}

        for key in ('checksum','container_format','disk_format','id','owner','size','is_public'):

            val = self.get_argument(key)

            if val is not None:

                params[key] = val

        try:

            self.client.register(name, location, params, self.get_argument('properties'))

        except ClientError as err:

            raiseCLIError(err)

@command()

class image_members(_init_image):

    """Get image members"""

    def main(self, image_id):

        super(self.__class__, self).main()

        try:

            members = self.client.list_members(image_id)

        except ClientError as err:

            raiseCLIError(err)

        for member in members:

            print(member['member_id'])

@command()

class image_shared(_init_image):

    """List shared images"""

    def main(self, member):

        super(self.__class__, self).main()

        try:

            images = self.client.list_shared(member)

        except ClientError as err:

            raiseCLIError(err)

        for image in images:

            print(image['image_id'])

@command()

class image_addmember(_init_image):

    """Add a member to an image"""

    def main(self, image_id, member):

        super(self.__class__, self).main()

        try:

            self.client.add_member(image_id, member)

        except ClientError as err:

            raiseCLIError(err)

@command()

class image_delmember(_init_image):

    """Remove a member from an image"""

    def main(self, image_id, member):

        super(self.__class__, self).main()

        try:

            self.client.remove_member(image_id, member)

        except ClientError as err:

            raiseCLIError(err)

@command()

class image_setmembers(_init_image):

    """Set the members of an image"""

    def main(self, image_id, *member):

        super(self.__class__, self).main()

        try:

            self.client.set_members(image_id, member)

        except ClientError as err:

            raiseCLIError(err)

@command()

class image_list(_init_cyclades):

    """List images"""

    def __init__(self, arguments={}):

        super(image_list, self).__init__(arguments)

        self.arguments['detail'] = FlagArgument('show detailed output', '-l')

    def _print(self, images):

        for img in images:

            iname = img.pop('name')

            iid = img.pop('id')

            print('%s (%s)'%(bold(iname), bold(unicode(iid))))

            if self.get_argument('detail'):

                image_info._print(img)

    def main(self):

        super(self.__class__, self).main()

        try:

            images = self.client.list_images(self.get_argument('detail'))

        except ClientError as err:

            raiseCLIError(err)

        self._print(images)

@command()

class image_info(_init_cyclades):

    """Get image details"""

    @classmethod

    def _print(self, image):

        if image.has_key('metadata'):

            image['metadata'] = image['metadata']['values']

        print_dict(image, ident=14)

    def main(self, image_id):

        super(self.__class__, self).main()

        try:

            image = self.client.get_image_details(image_id)

        except ClientError as err:

            raiseCLIError(err)

        self._print(image)

@command()

class image_delete(_init_cyclades):

    """Delete image"""

    def main(self, image_id):

        super(self.__class__, self).main()

        try:

            self.client.delete_image(image_id)

        except ClientError as err:

            raiseCLIError(err)

@command()

class image_properties(_init_cyclades):

    """Get image properties"""

    def main(self, image_id, key=None):

        super(self.__class__, self).main()

        try:

            reply = self.client.get_image_metadata(image_id, key)

        except ClientError as err:

            raiseCLIError(err)

        print_dict(reply)

@command()

class image_addproperty(_init_cyclades):

    """Add an image property"""

    def main(self, image_id, key, val):

        super(self.__class__, self).main()

        try:

            reply = self.client.create_image_metadata(image_id, key, val)

        except ClientError as err:

            raiseCLIError(err)

        print_dict(reply)

@command()

class image_setproperty(_init_cyclades):

    """Update an image property"""

    def main(self, image_id, key, val):

        super(self.__class__, self).main()

        metadata = {key: val}

        try:

            reply = self.client.update_image_metadata(image_id, **metadata)

        except ClientError as err:

            raiseCLIError(err)

        print_dict(reply)

@command()

class image_delproperty(_init_cyclades):

    """Delete an image property"""

    def main(self, image_id, key):

        super(self.__class__, self).main()

        try:

            self.client.delete_image_metadata(image_id, key)

        except ClientError as err:

            raiseCLIError(err)