Synnefo

import warnings

from operator import itemgetter

from django.conf import settings

PLANKTON_DOMAIN = 'plankton'

    pass

from pithos.backends.util import PithosBackendPool

POOL_SIZE = 8

_pithos_backend_pool = \

    return _pithos_backend_pool.pool_get()

class ImageBackend(object):

    """A wrapper arround the pithos backend to simplify image handling."""

        self.backend = get_pithos_backend()

        warnings.filters = original_filters     # Restore warnings

    def _get_image(self, location):

        def format_timestamp(t):

            return strftime('%Y-%m-%d %H:%M:%S', gmtime(t))

        return image

    def _get_meta(self, location, version=None):

        account, container, object = split_location(location)

        try:

        except NameError:

            return None

    def _get_permissions(self, location):

        account, container, object = split_location(location)

        action, path, permissions = self.backend.get_object_permissions(

                self.user, account, container, object)

        return permissions

    def _store(self, f, size=None):

        """Breaks data into blocks and stores them in the backend"""

        return hashmap, bytes

    def _update(self, location, size, hashmap, meta, permissions):

        account, container, object = split_location(location)

        self.backend.update_object_hashmap(self.user, account, container,

                permissions=permissions)

        self._update_meta(location, meta, replace=True)

    def _update_meta(self, location, meta, replace=False):

        account, container, object = split_location(location)

        self.backend.update_object_meta(self.user, account, container, object,

                PLANKTON_DOMAIN, prefixed, replace)

    def _update_permissions(self, location, permissions):

        account, container, object = split_location(location)

        self.backend.update_object_permissions(self.user, account, container,

                object, permissions)

    def add_user(self, image_id, user):

        image = self.get_image(image_id)

        assert image, "Image not found"

    def close(self):

        self.backend.close()

    def delete(self, image_id):

        image = self.get_image(image_id)

        account, container, object = split_location(image['location'])

        self.backend.delete_object(self.user, account, container, object)

    def get_data(self, location):

        account, container, object = split_location(location)

        size, hashmap = self.backend.get_object_hashmap(self.user, account,

        assert len(data) == size

        return data

    def get_image(self, image_id):

        try:

            account, container, object = self.backend.get_uuid(self.user,

        location = get_location(account, container, object)

        return self._get_image(location)

    def iter(self):

        """Iter over all images available to the user"""

                    if image:

                        yield image

    def iter_public(self, filters=None):

        filters = filters or {}

        backend = self.backend

                    if image:

                        yield image

    def iter_shared(self, member):

        """Iterate over image ids shared to this member"""

                except (NameError, NotAllowedError):

                    continue

    def list(self):

        """Iter over all images available to the user"""

        return list(self.iter())

    def list_public(self, filters, params):

        images = list(self.iter_public(filters))

        key = itemgetter(params.get('sort_key', 'created_at'))

        images.sort(key=key, reverse=reverse)

        return images

    def list_users(self, image_id):

        image = self.get_image(image_id)

        assert image, "Image not found"

        permissions = self._get_permissions(image['location'])

        return [user for user in permissions.get('read', []) if user != '*']

    def put(self, name, f, params):

        assert 'checksum' not in params, "Passing a checksum is not supported"

        assert 'id' not in params, "Passing an ID is not supported"

        self._update(location, size, hashmap, meta, permissions)

        return self._get_image(location)

    def register(self, name, location, params):

        assert 'id' not in params, "Passing an ID is not supported"

        assert location.startswith('pithos://'), "Invalid location"

        self._update_permissions(location, permissions)

        return self._get_image(location)

    def remove_user(self, image_id, user):

        image = self.get_image(image_id)

        assert image, "Image not found"

            return      # User did not have access anyway

        self._update_permissions(location, permissions)

    def replace_users(self, image_id, users):

        image = self.get_image(image_id)

        assert image, "Image not found"

            permissions['read'].append('*')

        self._update_permissions(location, permissions)

    def update(self, image_id, params):

        image = self.get_image(image_id)

        assert image, "Image not found"

        self._update_meta(location, meta)

        return self.get_image(image_id)