Synnefo

        since = utils.isoparse(request.GET.get('changes-since'))

    image = util.get_image(image_id, request.user_uniq)

    image = util.get_image(image_id, request.user_uniq)

    image = util.get_image(image_id, request.user_uniq)

    try:

        metadata = req['metadata']

        assert isinstance(metadata, dict)

    except (KeyError, AssertionError):

        raise faults.BadRequest('Malformed request.')

    properties = image['properties']

    properties.update(metadata)

    with image_backend(request.user_uniq) as backend:

        backend.update(image_id, dict(properties=properties))

    image = util.get_image(image_id, request.user_uniq)

    image = util.get_image(image_id, request.user_uniq)

    properties = image['properties']

    properties[key] = val

        backend.update(image_id, dict(properties=properties))

    image = util.get_image(image_id, request.user_uniq)

    properties = image['properties']

    properties.pop(key, None)

        backend.update(image_id, dict(properties=properties))

            num = len(backend.mock_calls) / 2

            assert(len(backend.return_value.close.mock_calls) == num)

@patch('synnefo.plankton.utils.ImageBackend')

        with patch('synnefo.api.util.get_image') as m:

            m.return_value = image

            response = self.get('/api/v1.1/images/42', 'user')

        with patch('synnefo.api.util.get_image') as m:

            m.side_effect = faults.ItemNotFound('Image not found')

            response = self.get('/api/v1.1/images/42', 'user')

@patch('synnefo.plankton.utils.ImageBackend')

        image = backend.get_image(image_id)

        if not image:

            raise faults.ItemNotFound('Image not found.')

        return image

# Copyright 2011 GRNET S.A. All rights reserved.

from operator import itemgetter

from functools import wraps, partial

from snf_django.lib.api import faults

from django.conf import settings

from pithos.backends.base import NotAllowedError

import logging

from synnefo.settings import (CYCLADES_USE_QUOTAHOLDER,

                              CYCLADES_QUOTAHOLDER_URL,

                              CYCLADES_QUOTAHOLDER_TOKEN,

                              CYCLADES_QUOTAHOLDER_POOLSIZE)

    except Exception, e:

        logger.exception(e)

class BackendException(Exception):

    pass

        quotaholder_enabled=CYCLADES_USE_QUOTAHOLDER,

        quotaholder_url=CYCLADES_QUOTAHOLDER_URL,

        quotaholder_token=CYCLADES_QUOTAHOLDER_TOKEN,

        quotaholder_client_poolsize=CYCLADES_QUOTAHOLDER_POOLSIZE,

            raise faults.Forbidden("Request not allowed")

    def _get_image(self, location):

        def format_timestamp(t):

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

        account, container, object = split_location(location)

        try:

            versions = self.backend.list_versions(self.user, account,

                                                  container, object)

        except NameError:

            return None

        meta = self._get_meta(location)

        if meta:

            image['deleted_at'] = ''

        else:

            meta = self._get_meta(location, version)

            image['deleted_at'] = format_timestamp(timestamp)

            return None     # Not a Plankton image

        permissions = self._get_permissions(location)

        image['checksum'] = meta['hash']

        image['created_at'] = format_timestamp(versions[0][1])

        image['id'] = meta['uuid']

        image['is_public'] = '*' in permissions.get('read', [])

        image['location'] = location

        image['size'] = meta['bytes']

        image['store'] = 'pithos'

        image['updated_at'] = format_timestamp(meta['modified'])

        image['properties'] = {}

            if not key.startswith(PLANKTON_PREFIX):

                continue

            key = key[len(PLANKTON_PREFIX):]

            if key == 'properties':

                val = json.loads(val)

            if key in PLANKTON_META:

                image[key] = val

    @handle_backend_exceptions

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

        account, container, object = split_location(location)

        try:

            return self.backend.get_object_meta(self.user, account, container,

                                                object, PLANKTON_DOMAIN,

                                                version)

        except NameError:

            return None

    @handle_backend_exceptions

    def _get_permissions(self, location):

        account, container, object = split_location(location)

        _a, _p, permissions = self.backend.get_object_permissions(self.user,

                                                                  account,

                                                                  container,

                                                                  object)

        return permissions

    @handle_backend_exceptions

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

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

        bytes = 0

        hashmap = []

        backend = self.backend

        blocksize = backend.block_size

        data = f.read(blocksize)

        while data:

            hash = backend.put_block(data)

            hashmap.append(hash)

            bytes += len(data)

            data = f.read(blocksize)

        if size and size != bytes:

            raise BackendException("Invalid size")

        return hashmap, bytes

    @handle_backend_exceptions

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

        account, container, object = split_location(location)

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

                                           object, size, hashmap, '',

                                           PLANKTON_DOMAIN,

                                           permissions=permissions)

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

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

        account, container, object = split_location(location)

        prefixed = {}

        for key, val in meta.items():

            if key == 'properties':

                val = json.dumps(val)

            if key in PLANKTON_META:

                prefixed[PLANKTON_PREFIX + key] = val

        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)

        if not image:

            raise faults.ItemNotFound

        location = image['location']

        permissions = self._get_permissions(location)

        read = set(permissions.get('read', []))

        read.add(user)

        permissions['read'] = list(read)

        self._update_permissions(location, permissions)

    def close(self):

        self.backend.close()

    def _delete(self, image_id):

        """Delete an Image.

        This method will delete the Image from the Storage backend.

        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,

                                                        container, object)

        data = ''.join(self.backend.get_block(hash) for hash in hashmap)

        assert len(data) == size

        return data

    def get_image(self, image_id):

        try:

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

                                                               image_id)

        except NameError:

            return None

        location = get_location(account, container, object)

        return self._get_image(location)

    def list_users(self, image_id):

        image = self.get_image(image_id)

        if not image:

            raise faults.ItemNotFound

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

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

    @handle_backend_exceptions

    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"

        assert params.pop('store', 'pithos') == 'pithos', "Invalid store"

        disk_format = params.setdefault('disk_format',

                                        settings.DEFAULT_DISK_FORMAT)

        assert disk_format in settings.ALLOWED_DISK_FORMATS,\

            "Invalid disk_format"

        assert params.setdefault('container_format',

                settings.DEFAULT_CONTAINER_FORMAT) in \

                settings.ALLOWED_CONTAINER_FORMATS, "Invalid container_format"

        container = settings.DEFAULT_PLANKTON_CONTAINER

        filename = params.pop('filename', name)

        location = 'pithos://%s/%s/%s' % (self.user, container, filename)

        is_public = params.pop('is_public', False)

        permissions = {'read': ['*']} if is_public else {}

        size = params.pop('size', None)

        hashmap, size = self._store(f, size)

        meta = {}

        meta['properties'] = params.pop('properties', {})

        meta.update(name=name, status='available', **params)

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

        return self._get_image(location)

    @handle_backend_exceptions

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

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

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

        assert params.pop('store', 'pithos') == 'pithos', "Invalid store"

        assert params.setdefault('disk_format',

                settings.DEFAULT_DISK_FORMAT) in \

                settings.ALLOWED_DISK_FORMATS, "Invalid disk_format"

        assert params.setdefault('container_format',

                settings.DEFAULT_CONTAINER_FORMAT) in \

                settings.ALLOWED_CONTAINER_FORMATS, "Invalid container_format"

        # user = self.user

        account, container, object = split_location(location)

        meta = self._get_meta(location)

        assert meta, "File not found"

        size = int(params.pop('size', meta['bytes']))

        if size != meta['bytes']:

            raise BackendException("Invalid size")

        checksum = params.pop('checksum', meta['hash'])

        if checksum != meta['hash']:

            raise BackendException("Invalid checksum")

        is_public = params.pop('is_public', False)

        if is_public:

            permissions = {'read': ['*']}

        else:

            permissions = {'read': [self.user]}

        meta = {}

        meta['properties'] = params.pop('properties', {})

        meta.update(name=name, status='available', **params)

        self._update_meta(location, meta)

        self._update_permissions(location, permissions)

        return self._get_image(location)

    @handle_backend_exceptions

    def remove_user(self, image_id, user):

        image = self.get_image(image_id)

        if not image:

            raise faults.ItemNotFound

        location = image['location']

        permissions = self._get_permissions(location)

        try:

            permissions.get('read', []).remove(user)

        except ValueError:

            return      # User did not have access anyway

        self._update_permissions(location, permissions)

    @handle_backend_exceptions

    def replace_users(self, image_id, users):

        image = self.get_image(image_id)

        if not image:

            raise faults.ItemNotFound

        location = image['location']

        permissions = self._get_permissions(location)

        permissions['read'] = users

        if image.get('is_public', False):

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

        self._update_permissions(location, permissions)

    @handle_backend_exceptions

    def update(self, image_id, params):

        image = self.get_image(image_id)

        assert image, "Image not found"

        if not image:

            raise faults.ItemNotFound

        location = image['location']

        is_public = params.pop('is_public', None)

        if is_public is not None:

            permissions = self._get_permissions(location)

            read = set(permissions.get('read', []))

            if is_public:

                read.add('*')

            else:

                read.discard('*')

            permissions['read'] = list(read)

            self.backend._update_permissions(location, permissions)

        meta = {}

        meta['properties'] = params.pop('properties', {})

        meta.update(**params)

        self._update_meta(location, meta)

        return self.get_image(image_id)

    @handle_backend_exceptions

    def unregister(self, image_id):

        """Unregister an image."""

        image = self.get_image(image_id)

        if not image:

            raise faults.ItemNotFound

        location = image["location"]

        # Unregister the image by removing all metadata from domain

        # 'PLANKTON_DOMAIN'

        meta = self._get_meta(location)

        for k in meta.keys():

            meta[k] = ""

        self._update_meta(location, meta, False)

from django.test import TestCase

from contextlib import contextmanager

from snf_django.utils.testing import astakos_user, BaseAPITest

@patch("synnefo.plankton.utils.ImageBackend")

# Copyright 2011 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.

from functools import wraps

from logging import getLogger

from traceback import format_exc

from django.conf import settings

from django.http import (HttpResponse, HttpResponseBadRequest,

                         HttpResponseServerError, HttpResponseForbidden)

from snf_django.lib.api import faults

from snf_django.lib.astakos import get_user

from synnefo.plankton.backend import (ImageBackend, BackendException,

                                      NotAllowedError)

log = getLogger('synnefo.plankton')

def plankton_method(method):

    def decorator(func):

        @wraps(func)

        def wrapper(request, *args, **kwargs):

            try:

                get_user(request, settings.ASTAKOS_URL)

                if not request.user_uniq:

                    return HttpResponse(status=401)

                if request.method != method:

                    return HttpResponse(status=405)

                request.backend = ImageBackend(request.user_uniq)

                return func(request, *args, **kwargs)

            except (AssertionError, BackendException) as e:

                message = e.args[0] if e.args else ''

                return HttpResponseBadRequest(message)

            except NotAllowedError:

                return HttpResponseForbidden()

            except faults.Fault, fault:

                return HttpResponse(status=fault.code)

            except Exception as e:

                if settings.DEBUG:

                    message = format_exc(e)

                else:

                    message = ''

                log.exception(e)

                return HttpResponseServerError(message)

            finally:

                if hasattr(request, 'backend'):

                    request.backend.close()

        return wrapper

    return decorator

# Copyright 2011 GRNET S.A. All rights reserved.

from functools import wraps

from synnefo.plankton.backend import ImageBackend

def plankton_method(func):

    """Decorator function for API methods using ImageBackend.

    Decorator function that creates and closes an ImageBackend, needed

    by all API methods that handle images.

    """

    @wraps(func)

    def wrapper(request, *args, **kwargs):

        with image_backend(request.user_uniq) as backend:

            request.backend = backend

            return func(request, *args, **kwargs)

    return wrapper

    """Context manager for ImageBackend"""

    backend = ImageBackend(user_id)

        yield backend

        backend.close()

from synnefo.plankton.utils import plankton_method

@plankton_method

        image = request.backend.register(name, location, params)

        #image = request.backend.put(name, f, params)

@plankton_method

    request.backend.unregister(image_id)

@plankton_method

    request.backend.add_user(image_id, member)

@plankton_method

    #image = request.backend.get_image(image_id)

    #data = request.backend.get_data(image)

@plankton_method

    image = request.backend.get_image(image_id)

    if not image:

        raise faults.ItemNotFound()

@plankton_method

    members = [{'member_id': user, 'can_share': False}

               for user in request.backend.list_users(image_id)]

@plankton_method

    images = request.backend.list(filters, params)

@plankton_method

    for image in request.backend.iter_shared(member=member):

        image_id = image['id']

        images.append({'image_id': image_id, 'can_share': False})

@plankton_method

    request.backend.remove_user(image_id, member)

@plankton_method

    image = request.backend.update(image_id, meta)

@plankton_method

    request.backend.replace_users(image_id, members)