Synnefo » Pithos

    if not limit:

        limit = 10000

    if request.serialization == 'text':

        if len(accounts) == 0:

    account_meta = []

    for x in accounts:

        try:

        except NotAllowedError:

            raise Forbidden('Not allowed')

        else:

    until = get_int_parameter(request.GET.get('until'))

    try:

    except NotAllowedError:

        raise Forbidden('Not allowed')

        replace = False

    if groups:

        try:

                                                    groups, replace)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise BadRequest('Invalid groups header')

    if meta or replace:

        try:

                                                replace)

        except NotAllowedError:

            raise Forbidden('Not allowed')

    until = get_int_parameter(request.GET.get('until'))

    try:

    except NotAllowedError:

        raise Forbidden('Not allowed')

        shared = True

    try:

                                                marker, limit, shared, until)

    except NotAllowedError:

        raise Forbidden('Not allowed')

    container_meta = []

    for x in containers:

        try:

                                                        x, until)

                                                            v_account, x)

        except NotAllowedError:

            raise Forbidden('Not allowed')

    until = get_int_parameter(request.GET.get('until'))

    try:

                                                    v_container, until)

                                                v_account, v_container, until)

                                                        v_container)

    except NotAllowedError:

        raise Forbidden('Not allowed')

    meta, policy = get_container_headers(request)

    try:

        ret = 201

    except NotAllowedError:

        raise Forbidden('Not allowed')

    if ret == 202 and policy:

        try:

                                            v_container, policy, replace=False)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise BadRequest('Invalid policy header')

    if meta:

        try:

                                            v_container, meta, replace=False)

        except NotAllowedError:

            raise Forbidden('Not allowed')

        replace = False

    if policy:

        try:

                                                v_container, policy, replace)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise BadRequest('Invalid policy header')

    if meta or replace:

        try:

                                                    v_container, meta, replace)

        except NotAllowedError:

            raise Forbidden('Not allowed')

    until = get_int_parameter(request.GET.get('until'))

    try:

                                            until)

    except NotAllowedError:

        raise Forbidden('Not allowed')

    until = get_int_parameter(request.GET.get('until'))

    try:

                                                    v_container, until)

                                                v_account, v_container, until)

                                                        v_container)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        shared = True

    try:

                                    v_container, prefix, delimiter, marker,

                                    limit, virtual, keys, shared, until)

    except NotAllowedError:

            object_meta.append({'subdir': x[0]})

        else:

            try:

                                                        v_container, x[0], x[1])

                if until is None:

                    permissions = request.backend.get_object_permissions(

                                                v_account, v_container, x[0])

                else:

                    permissions = None

    version = request.GET.get('version')

    try:

                                                v_container, v_object, version)

        if version is None:

                                            v_account, v_container, v_object)

                                                        v_container, v_object)

        else:

            permissions = None

            raise BadRequest('No format specified for version list.')

        try:

                                                v_container, v_object)

        except NotAllowedError:

            raise Forbidden('Not allowed')

        return response

    try:

                                                v_container, v_object, version)

        if version is None:

                                            v_account, v_container, v_object)

                                                        v_container, v_object)

        else:

            permissions = None

    if 'X-Object-Manifest' in meta:

        try:

            src_container, src_name = split_container_object_string('/' + meta['X-Object-Manifest'])

                                src_container, prefix=src_name, virtual=False)

        except NotAllowedError:

            raise Forbidden('Not allowed')

        try:

            for x in objects:

                                        v_account, src_container, x[0], x[1])

                sizes.append(s)

                hashmaps.append(h)

            raise ItemNotFound('Version does not exist')

    else:

        try:

                                                v_container, v_object, version)

            sizes.append(s)

            hashmaps.append(h)

    # Evaluate conditions.

    if request.META.get('HTTP_IF_MATCH') or request.META.get('HTTP_IF_NONE_MATCH'):

        try:

                                                        v_container, v_object)

        except NotAllowedError:

            raise Forbidden('Not allowed')

        src_account = smart_unicode(request.META.get('HTTP_X_SOURCE_ACCOUNT'), strings_only=True)

        if not src_account:

        if move_from:

            try:

                src_container, src_name = split_container_object_string(move_from)

            raise UnprocessableEntity('Object ETag does not match')

    try:

                        v_account, v_container, v_object, size, hashmap, meta,

                        True, permissions)

    except NotAllowedError:

        raise RequestEntityTooLarge('Quota exceeded')

    if public is not None:

        try:

                                                v_container, v_object, public)

        except NotAllowedError:

            raise Forbidden('Not allowed')

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

    try:

                    v_account, v_container, v_object, size, hashmap, meta, True)

    except NotAllowedError:

        raise Forbidden('Not allowed')

    dest_account = smart_unicode(request.META.get('HTTP_DESTINATION_ACCOUNT'), strings_only=True)

    if not dest_account:

    dest_path = smart_unicode(request.META.get('HTTP_DESTINATION'), strings_only=True)

    if not dest_path:

        raise BadRequest('Missing Destination header')

    if request.META.get('HTTP_IF_MATCH') or request.META.get('HTTP_IF_NONE_MATCH'):

        src_version = request.META.get('HTTP_X_SOURCE_VERSION')

        try:

                                            v_container, v_object, src_version)

        except NotAllowedError:

            raise Forbidden('Not allowed')

    dest_account = smart_unicode(request.META.get('HTTP_DESTINATION_ACCOUNT'), strings_only=True)

    if not dest_account:

    dest_path = smart_unicode(request.META.get('HTTP_DESTINATION'), strings_only=True)

    if not dest_path:

        raise BadRequest('Missing Destination header')

    # Evaluate conditions.

    if request.META.get('HTTP_IF_MATCH') or request.META.get('HTTP_IF_NONE_MATCH'):

        try:

                                                    v_container, v_object)

        except NotAllowedError:

            raise Forbidden('Not allowed')

        del(meta['Content-Type']) # Do not allow changing the Content-Type.

    try:

                                                    v_container, v_object)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        # Do permissions first, as it may fail easier.

        if permissions is not None:

            try:

                                v_account, v_container, v_object, permissions)

            except NotAllowedError:

                raise Forbidden('Not allowed')

                raise Conflict('\n'.join(e.data) + '\n')

        if public is not None:

            try:

                                                v_container, v_object, public)

            except NotAllowedError:

                raise Forbidden('Not allowed')

                raise ItemNotFound('Object does not exist')

        if meta or replace:

            try:

                                v_account, v_container, v_object, meta, replace)

            except NotAllowedError:

                raise Forbidden('Not allowed')

        raise RangeNotSatisfiable('Invalid Content-Range header')

    try:

                                            v_account, v_container, v_object)

    except NotAllowedError:

        raise Forbidden('Not allowed')

    if src_object:

        src_account = smart_unicode(request.META.get('HTTP_X_SOURCE_ACCOUNT'), strings_only=True)

        if not src_account:

        src_container, src_name = split_container_object_string(src_object)

        src_container = smart_unicode(src_container, strings_only=True)

        src_name = smart_unicode(src_name, strings_only=True)

        src_version = request.META.get('HTTP_X_SOURCE_VERSION')

        try:

                                        src_account, src_container, src_name, src_version)

        except NotAllowedError:

            raise Forbidden('Not allowed')

        hashmap = hashmap[:(int((size - 1) / request.backend.block_size) + 1)]

    meta.update({'hash': hashmap_hash(request, hashmap)}) # Update ETag.

    try:

                        v_account, v_container, v_object, size, hashmap, meta,

                        replace, permissions)

    except NotAllowedError:

        raise RequestEntityTooLarge('Quota exceeded')

    if public is not None:

        try:

                                                v_container, v_object, public)

        except NotAllowedError:

            raise Forbidden('Not allowed')

    until = get_int_parameter(request.GET.get('until'))

    try:

                                        v_object, until)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        bytes = 0

        try:

            src_container, src_name = split_container_object_string('/' + meta['X-Object-Manifest'])

                                src_container, prefix=src_name, virtual=False)

            for x in objects:

                                        v_account, src_container, x[0], x[1])

                hash += src_meta['hash']

                bytes += src_meta['bytes']

    meta['X-Object-Sharing'] = '; '.join(ret)

    if '/'.join((v_account, v_container, v_object)) != perm_path:

        meta['X-Object-Shared-By'] = perm_path

        meta['X-Object-Allowed-To'] = allowed

def update_public_meta(public, meta):

    src_version = request.META.get('HTTP_X_SOURCE_VERSION')

    try:

        if move:

                                                        dest_account, dest_container, dest_name,

                                                        meta, False, permissions)

        else:

                                                        dest_account, dest_container, dest_name,

                                                        meta, False, permissions, src_version)

    except NotAllowedError:

        raise RequestEntityTooLarge('Quota exceeded')

    if public is not None:

        try:

        except NotAllowedError:

            raise Forbidden('Not allowed')

        except NameError:

                next = urlencode({'next': request.build_absolute_uri()})

                login_uri = reverse(index) + '?' + next

                return HttpResponseRedirect(login_uri)

                return HttpResponse('Forbidden', status=403)

        return func(request, *args)

    return wrapper

    message = None

    if request.method == 'POST':

            code = generate_invitation_code()

            invitation, created = Invitation.objects.get_or_create(code=code)

            invitation.realname=request.POST.get('realname')

            invitation.uniq=request.POST.get('uniq')

            invitation.save()

            message = _('No invitations left')

    if request.GET.get('format') == 'json':

        return HttpResponse(json.dumps(rep))

    html = render_to_string('invitations.html', {

            'status': status,

            'message': message})

    return HttpResponse(html)

class AuthMiddleware(object):

    def process_request(self, request):

        request.user = None

        # Try to find token in a parameter, in a request header, or in a cookie.

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

        if (time() - mktime(user.auth_token_expires.timetuple())) > 0:

            return

    def process_response(self, request, response):

        return response

    #                       badRequest (400)

    try:

                                                v_container, v_object)

                                                    v_container, v_object)

    except:

        raise ItemNotFound('Object does not exist')

    #                       notModified (304)

    try:

                                                v_container, v_object)

                                                    v_container, v_object)

    except:

        raise ItemNotFound('Object does not exist')

    if 'X-Object-Manifest' in meta:

        try:

            src_container, src_name = split_container_object_string('/' + meta['X-Object-Manifest'])

                                src_container, prefix=src_name, virtual=False)

        except:

            raise ItemNotFound('Object does not exist')

        try:

            for x in objects:

                                        v_account, src_container, x[0], x[1])

                sizes.append(s)

                hashmaps.append(h)

            raise ItemNotFound('Object does not exist')

    else:

        try:

                                                        v_container, v_object)

            sizes.append(s)

            hashmaps.append(h)