Synnefo

# or implied, of GRNET S.A.

from functools import wraps

from datetime import datetime

from urllib import quote, unquote

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

                                 BACKEND_ACCOUNT_QUOTA, BACKEND_CONTAINER_QUOTA,

                                 BACKEND_VERSIONING,

                                 BACKEND_FREE_VERSIONING, BACKEND_POOL_SIZE,

                                 RADOS_STORAGE, RADOS_POOL_BLOCKS,

                                 RADOS_POOL_MAPS, TRANSLATE_UUIDS,

                                 PUBLIC_URL_SECURITY,

from pithos.backends.base import (NotAllowedError, QuotaError, ItemNotExists,

                                  VersionNotExists)

from snf_django.lib.astakos import (get_user_uuid, get_displayname,

import logging

import re

def get_header_prefix(request, prefix):

    prefix = 'HTTP_' + prefix.upper().replace('-', '_')

    # TODO: Document or remove '~' replacing.

def check_meta_headers(meta):

        v = smart_str(','.join(v), strings_only=True)

        response[k] = v

    for k, v in policy.iteritems():

def get_container_headers(request):

    meta = get_header_prefix(request, 'X-Container-Meta-')

    check_meta_headers(meta)

    return meta, policy

        response['X-Container-Until-Timestamp'] = http_date(

            int(meta['until_timestamp']))

    for k, v in policy.iteritems():

def get_object_headers(request):

        response['X-Object-Hash'] = meta['hash']

        response['X-Object-UUID'] = meta['uuid']

        if TRANSLATE_UUIDS:

        response['X-Object-Modified-By'] = smart_str(

            meta['modified_by'], strings_only=True)

        response['X-Object-Version'] = meta['version']

                src_container, prefix=src_name, virtual=False)

            for x in objects:

                src_meta = request.backend.get_object_meta(request.user_uniq,

                etag += src_meta['checksum']

                bytes += src_meta['bytes']

        except:

        md5.update(etag)

        meta['checksum'] = md5.hexdigest().lower()

def is_uuid(str):

    if str is None:

        return False

    except ValueError:

        return False

    else:

##########################

# USER CATALOG utilities #

        return uuid

    return displayname

def retrieve_displaynames(token, uuids, return_dict=False, fail_silently=True):

    missing = list(set(uuids) - set(catalog))

    if missing and not fail_silently:

        raise ItemNotExists('Unknown displaynames: %s' % ', '.join(missing))

    return catalog if return_dict else [catalog.get(i) for i in uuids]

def retrieve_uuid(token, displayname):

    if is_uuid(displayname):

        return displayname

        raise ItemNotExists(displayname)

    return uuid

def retrieve_uuids(token, displaynames, return_dict=False, fail_silently=True):

    catalog = get_uuids(token, displaynames, USER_CATALOG_URL) or {}

    missing = list(set(displaynames) - set(catalog))

        raise ItemNotExists('Unknown uuids: %s' % ', '.join(missing))

    return catalog if return_dict else [catalog.get(i) for i in displaynames]

def replace_permissions_displayname(token, holder):

    if holder == '*':

        return holder

    else:

        return ':'.join([retrieve_uuid(token, account), group])

def replace_permissions_uuid(token, holder):

    if holder == '*':

        return holder

    else:

        return ':'.join([retrieve_displayname(token, account), group])

    if permissions is None:

        return

    allowed, perm_path, perms = permissions

    # replace uuid with displayname

    if TRANSLATE_UUIDS:

        perms['read'] = [replace_permissions_uuid(

        perms['write'] = [replace_permissions_uuid(

    ret = []

    if_modified_since = request.META.get('HTTP_IF_MODIFIED_SINCE')

    if if_modified_since is not None:

        if_modified_since = parse_http_date_safe(if_modified_since)

        raise faults.NotModified('Resource has not been modified')

    if_unmodified_since = request.META.get('HTTP_IF_UNMODIFIED_SINCE')

    if if_unmodified_since is not None:

        if_unmodified_since = parse_http_date_safe(if_unmodified_since)

        raise faults.PreconditionFailed('Resource has been modified')

    if if_match is not None:

        if etag is None:

            raise faults.PreconditionFailed('Resource does not exist')

            raise faults.PreconditionFailed('Resource ETag does not match')

    if_none_match = request.META.get('HTTP_IF_NONE_MATCH')

    if if_none_match is not None:

        # TODO: If this passes, must ignore If-Modified-Since header.

        if etag is not None:

                # TODO: Continue if an If-Modified-Since header is present.

                if request.method in ('HEAD', 'GET'):

                    raise faults.NotModified('Resource ETag matches')

def split_container_object_string(s):

    return s[:pos], s[(pos + 1):]

    """Copy or move an object."""

    if 'ignore_content_type' in request.GET and 'CONTENT_TYPE' in request.META:

            version_id = request.backend.copy_object(

                request.user_uniq, src_account, src_container, src_name,

                dest_account, dest_container, dest_name,

    except NotAllowedError:

        raise faults.Forbidden('Not allowed')

    except (ItemNotExists, VersionNotExists):

        raise faults.RequestEntityTooLarge('Quota error: %s' % e)

    if public is not None:

        try:

        except NotAllowedError:

            raise faults.Forbidden('Not allowed')

        except ItemNotExists:

    if TRANSLATE_UUIDS:

        try:

            ret['read'] = [replace_permissions_displayname(

            ret['write'] = [replace_permissions_displayname(

        except ItemNotExists, e:

            raise faults.BadRequest(

                'Bad X-Object-Sharing header value: unknown account: %s' % e)

def socket_read_iterator(request, length=0, blocksize=4096):

    Read up to 'length'. If 'length' is negative, will attempt a chunked read.

    The maximum ammount of data read is controlled by MAX_UPLOAD_SIZE.

    sock = raw_input_socket(request)

    if length < 0:  # Chunked transfers

        # Small version (server does the dechunking).

            while length < MAX_UPLOAD_SIZE:

                data = sock.read(blocksize)

                if data == '':

            self.md5.update(block)

            self.data = self.data[length:]

        self.md5 = hashlib.md5()

        self.data = ''

        self.file = UploadedFile(

class ObjectWrapper(object):

    """Return the object's data block-per-block in each iteration.

    """

    def __init__(self, backend, ranges, sizes, hashmaps, boundary):

            # Get the block for the current position.

            self.block_index = int(self.offset / self.backend.block_size)

                self.block_hash = self.hashmaps[

                    self.file_index][self.block_index]

                try:

                 offset < 0 or offset >= size or

                 offset + length > size]

        if len(check) > 0:

        ret = 206

        if_range = request.META.get('HTTP_IF_RANGE')

        if if_range:

    wrapper = ObjectWrapper(request.backend, ranges, sizes, hashmaps, boundary)

    response = HttpResponse(wrapper, status=ret)

    put_object_headers(

    if ret == 206:

        if len(ranges) == 1:

            offset, length = ranges[0]

def hashmap_md5(backend, hashmap, size):

    """Produce the MD5 sum from the data in the hashmap."""

    md5 = hashlib.md5()

    bs = backend.block_size

    for bi, hash in enumerate(hashmap):

from pithos.backends.util import PithosBackendPool

if RADOS_STORAGE:

else:

_pithos_backend_pool = PithosBackendPool(

def get_backend():