Synnefo » ./kamaki

howto_image_file = [

    'Kamaki commands to:',

    ' get current user uuid: /user authenticate',

    ' check available containers: /file list',

    ' create a new container: /file create <container>',

    ' check container contents: /file list <container>',

    ' upload files: /file upload <image file> <container>']

about_image_id = ['To see a list of available image ids: /image list']

def _validate_image_meta(json_dict, return_str=False):

    :returns: (dict) if return_str is not True, else return str

        if k.lower() == 'properties':

            for pk, pv in v.items():

                prop_ok = not (isinstance(pv, dict) or isinstance(pv, list))

                assert prop_ok, 'Invalid property value for key %s' % pk

                key_ok = not (' ' in k or '-' in k)

                assert key_ok, 'Invalid property key %s' % k

            continue

        meta_ok = not (isinstance(v, dict) or isinstance(v, list))

        assert meta_ok, 'Invalid value for meta key %s' % k

        meta_ok = ' ' not in k

        assert meta_ok, 'Invalid meta key [%s]' % k

def _load_image_meta(filepath):

            return _validate_image_meta(meta_dict)

def _validate_image_location(location):

    """

    :param location: (str) pithos://<uuid>/<container>/<img-file-path>

    :returns: (<uuid>, <container>, <img-file-path>)

    :raises AssertionError: if location is invalid

    """

    prefix = 'pithos://'

    msg = 'Invalid prefix for location %s , try: %s' % (location, prefix)

    assert location.startswith(prefix), msg

    service, sep, rest = location.partition('://')

    assert sep and rest, 'Location %s is missing uuid' % location

    uuid, sep, rest = rest.partition('/')

    assert sep and rest, 'Location %s is missing container' % location

    container, sep, img_path = rest.partition('/')

    assert sep and img_path, 'Location %s is missing image path' % location

    return uuid, container, img_path

        metafile=ValueArgument(

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

            '{"key1": "val1", "key2": "val2", ..., "properties: {...}"}',

            ('--metafile')),

        metafile_force=FlagArgument(

            'Store remote metadata object, even if it already exists',

            ('-f', '--force')),

        no_metafile_upload=FlagArgument(

            'Do not store metadata in remote meta file',

            ('--no-metafile-upload')),

    def _get_pithos_client(self, container):

        if self['no_metafile_upload']:

            return None

        return PithosClient(purl, ptoken, self._get_uuid(), container)

    def _store_remote_metafile(self, pclient, remote_path, metadata):

            remote_path, _validate_image_meta(metadata, return_str=True))

    def _load_params_from_file(self, location):

        params, properties = dict(), dict()

        pfile = self['metafile']

        if pfile:

                for k, v in _load_image_meta(pfile).items():

                    key = k.lower().replace('-', '_')

                    if k == 'properties':

                        for pk, pv in v.items():

                            properties[pk.upper().replace('-', '_')] = pv

                    elif key == 'name':

                            continue

                    elif key == 'location':

                        if location:

                            continue

                        location = v

                    else:

                        params[key] = v

            except Exception as e:

                raiseCLIError(e, 'Invalid json metadata config file')

        return params, properties, location

    def _load_params_from_args(self, params, properties):

        for k, v in self['properties'].items():

            properties[k.upper().replace('-', '_')] = v

    def _validate_location(self, location):

        if not location:

            raiseCLIError(

                'No image file location provided',

                importance=2, details=[

                    'An image location is needed. Image location format:',

                    '  pithos://<uuid>/<container>/<path>',

                    ' an image file at the above location must exist.'

                    ] + howto_image_file)

        try:

            return _validate_image_location(location)

        except AssertionError as ae:

            raiseCLIError(

                ae, 'Invalid image location format',

                importance=1, details=[

                    'Valid image location format:',

                    '  pithos://<uuid>/<container>/<img-file-path>'

                    ] + howto_image_file)

    @errors.generic.all

    @errors.plankton.connection

    def _run(self, name, location):

        (params, properties, location) = self._load_params_from_file(location)

        uuid, container, img_path = self._validate_location(location)

        self._load_params_from_args(params, properties)

        pclient = self._get_pithos_client(container)

        #check if metafile exists

        meta_path = '%s.meta' % img_path

        if pclient and not self['metafile_force']:

                pclient.get_object_info(meta_path)

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

                    container, meta_path))

            except ClientError as ce:

                if ce.status != 404:

                    raise

        #register the image

        try:

            r = self.client.register(name, location, params, properties)

        except ClientError as ce:

            if ce.status in (400, ):

                    ce, 'Nonexistent image file location %s' % location,

                        'Make sure the image file exists'] + howto_image_file)

            raise

        self._print(r, print_dict)

        #upload the metadata file

            try:

                meta_headers = pclient.upload_from_string(

                    meta_path, dumps(r, indent=2))

            except TypeError:

                print('Failed to dump metafile %s:%s' % (container, meta_path))

                return

                    metafile_location='%s:%s' % (container, meta_path),

                    headers=meta_headers))

                print('Metadata file uploaded as %s:%s (version %s)' % (

                    container, meta_path, meta_headers['x-object-version']))

    def main(self, name, location=None):

        self._run(name, location)