Synnefo

from synnefo.lib.parsedate import parse_http_date_safe, parse_http_date

from synnefo.lib.astakos import get_user

from pithos.api.settings import (BACKEND_DB_MODULE, BACKEND_DB_CONNECTION,

                                 BACKEND_BLOCK_MODULE, BACKEND_BLOCK_PATH,

                                 BACKEND_BLOCK_UMASK,

def check_meta_headers(meta):

    if len(meta) > 90:

    for k, v in meta.iteritems():

        if len(k) > 128:

        if len(v) > 256:

def get_account_headers(request):

    for k, v in get_header_prefix(request, 'X-Account-Group-').iteritems():

        n = k[16:].lower()

        if '-' in n or '_' in n:

        groups[n] = v.replace(' ', '').split(',')

        while '' in groups[n]:

            groups[n].remove('')

    if if_modified_since is not None:

        if_modified_since = parse_http_date_safe(if_modified_since)

    if if_modified_since is not None and int(meta['modified']) <= if_modified_since:

    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)

    if if_unmodified_since is not None and int(meta['modified']) > if_unmodified_since:

def validate_matching_preconditions(request, meta):

    if_match = request.META.get('HTTP_IF_MATCH')

    if if_match is not None:

        if etag is None:

        if if_match != '*' and etag not in [x.lower() for x in parse_etags(if_match)]:

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

    if if_none_match is not None:

            if if_none_match == '*' or etag in [x.lower() for x in parse_etags(if_none_match)]:

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

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

def split_container_object_string(s):

                dest_account, dest_container, dest_name,

                content_type, 'pithos', meta, False, permissions, src_version, delimiter)

    except NotAllowedError:

    except (ItemNotExists, VersionNotExists):

    except ValueError:

    except QuotaError, e:

    if public is not None:

        try:

            request.backend.update_object_public(request.user_uniq, dest_account, dest_container, dest_name, public)

        except NotAllowedError:

        except ItemNotExists:

    return version_id

def get_content_length(request):

    content_length = get_int_parameter(request.META.get('CONTENT_LENGTH'))

    if content_length is None:

    return content_length

            if '*' in ret['read']:

                ret['read'] = ['*']

            if len(ret['read']) == 0:

                    'Bad X-Object-Sharing header value: invalid length')

        elif perm.startswith('write='):

            ret['write'] = list(set(

            if '*' in ret['write']:

                ret['write'] = ['*']

            if len(ret['write']) == 0:

                    'Bad X-Object-Sharing header value: invalid length')

        else:

                'Bad X-Object-Sharing header value: missing prefix')

    # replace displayname with uuid

                    getattr(request, 'token', None), x) \

                        for x in ret.get('write', [])]

        except ItemNotExists, e:

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

    # Keep duplicates only in write list.

        return True

    elif public == 'false' or public == '':

        return False

def raw_input_socket(request):

                if data == '':

                    return

                yield data

        # Long version (do the dechunking).

        data = ''

                chunk_length = chunk_length[:pos]

            try:

                chunk_length = int(chunk_length, 16)

                                 # TODO: Change to something more appropriate.

            # Check if done.

            if chunk_length == 0:

                    data = data[blocksize:]

                    yield ret

            sock.read(2)  # CRLF

    else:

        if length > MAX_UPLOAD_SIZE:

        while length > 0:

            data = sock.read(min(length, blocksize))

            if not data:

            length -= len(data)

            yield data

                try:

                    self.block = self.backend.get_block(self.block_hash)

                except ItemNotExists:

            # Get the data from the block.

            bo = self.offset % self.backend.block_size

                 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:

            k.decode('ascii')

            v.decode('ascii')

        except UnicodeDecodeError:

        if '%' in k or '%' in v:

            del(request.META[k])

            request.META[unquote(k)] = smart_unicode(unquote(

def render_fault(request, fault):

        fault.details = format_exc(fault)

    request.serialization = 'text'

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

            try:

                if http_method and request.method != http_method:

                if user_required:

                    token = None

                             token,

                             request_usage)

                    if  getattr(request, 'user', None) is None:

                    assert getattr(request, 'user_uniq', None) != None

                    request.user_usage = get_pithos_usage(request.user.get('usage', []))

                    request.token = request.GET.get('X-Auth-Token', request.META.get('HTTP_X_AUTH_TOKEN', token))

                # The args variable may contain up to (account, container, object).

                if len(args) > 1 and len(args[1]) > 256:

                if len(args) > 2 and len(args[2]) > 1024:

                # Format and check headers.

                update_request_headers(request)

                response = func(request, *args, **kwargs)

                update_response_headers(request, response)

                return response

                if fault.code >= 500:

                    logger.exception("API Fault")

                return render_fault(request, fault)

            except BaseException, e:

                logger.exception('Unexpected error: %s' % e)

                return render_fault(request, fault)

            finally:

                if getattr(request, 'backend', None) is not None: