Synnefo » ./kamaki

- Store image properties on remote location after image registration [#3769]

- Add runtime args to image register for forcing or unsettitng property

    storage [#3769]

from kamaki.clients.pithos import PithosClient

from kamaki.clients.astakos import AstakosClient

from kamaki.clients import ClientError

from kamaki.cli.errors import raiseCLIError

            'Load properties from a json-formated file <img-file>.meta :'

            ('--property-file')),

        prop_file_force=FlagArgument(

            'Store remote property object, even it already exists',

            ('-f', '--force-upload-property-file')),

        no_prop_file_upload=FlagArgument(

            'Do not store properties in remote property file',

            ('--no-property-file-upload')),

        container=ValueArgument(

            'Remote image container', ('-C', '--container')),

        fileowner=ValueArgument(

            'UUID of the user who owns the image file', ('--fileowner'))

    def _get_uuid(self):

        uuid = self['fileowner'] or self.config.get('image', 'fileowner')

        if uuid:

            return uuid

        atoken = self.client.token

        user = AstakosClient(self.config.get('user', 'url'), atoken)

        return user.term('uuid')

    def _get_pithos_client(self, uuid, container):

        purl = self.config.get('file', 'url')

        ptoken = self.client.token

        return PithosClient(purl, ptoken, uuid, container)

    def _store_remote_property_file(self, pclient, remote_path, properties):

        return pclient.upload_from_string(

            remote_path, _validate_image_props(properties, return_str=True))

    def _get_container_path(self, container_path):

        container = self['container'] or self.config.get('image', 'container')

        if container:

            return container, container_path

        container, sep, path = container_path.partition(':')

        if not sep or not container or not path:

            raiseCLIError(

                '%s is not a valid pithos remote location' % container_path,

                details=[

                    'To set "image" as container and "my_dir/img.diskdump" as',

                    'the image path, try one of the following as '

                    'container:path',

                    '- <image container>:<remote path>',

                    '    e.g. image:/my_dir/img.diskdump',

                    '- <remote path> -C <image container>',

                    '    e.g. /my_dir/img.diskdump -C image'])

        return container, path

    def _run(self, name, container_path):

        container, path = self._get_container_path(container_path)

        uuid = self._get_uuid()

        prop_path = '%s.meta' % path

        pclient = None if (

            self['no_prop_file_upload']) else self._get_pithos_client(

                uuid, container)

        if pclient and not self['prop_file_force']:

            try:

                pclient.get_object_info(prop_path)

                raiseCLIError('Property file %s: %s already exists' % (

                    container, prop_path))

            except ClientError as ce:

                if ce.status != 404:

                    raise

        location = 'pithos://%s/%s/%s' % (uuid, container, path)

        if pclient:

            prop_headers = pclient.upload_from_string(

                prop_path, _validate_image_props(properties, return_str=True))

            print('Property file location is %s: %s' % (container, prop_path))

            print('\twith version %s' % prop_headers['x-object-version'])

    def main(self, name, container___path):

        self._run(name, container___path)

    def format_permission_dict(self, permissions):

            read_permission=read, write_permission=write))

        (read, write) = self.format_permission_dict(permissions)

            read_permission=False, write_permission=False):

        :param read_permission: (list - bool) users and user groups that get

            read permission for this object - False means all previous read

        :param write_permission: (list - bool) of users and user groups to get

           write permission for this object - False means all previous write

        perms = dict(read=read_permission or '', write=write_permission or '')