Synnefo

    SaveToBackendHandler, object_data_response, put_object_block, hashmap_md5, simple_list_response, api_method)

from pithos.api.settings import UPDATE_MD5

from pithos.backends.filter import parse_filters

import logging

                                                        v_container)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container does not exist')

    validate_modification_preconditions(request, meta)

                                            v_container, policy, replace=False)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container does not exist')

        except ValueError:

            raise BadRequest('Invalid policy header')

                                            v_container, 'pithos', meta, replace=False)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container does not exist')

    return HttpResponse(status=ret)

                                                v_container, policy, replace)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container does not exist')

        except ValueError:

            raise BadRequest('Invalid policy header')

                                                    v_container, 'pithos', meta, replace)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container does not exist')

    content_length = -1

                                            until)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container does not exist')

        raise Conflict('Container is not empty')

    return HttpResponse(status=204)

                                                        v_container)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container does not exist')

    validate_modification_preconditions(request, meta)

                                        until, None, public)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container does not exist')

        if len(objects) == 0:

                object_public[k[name_idx:]] = v

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container does not exist')

    object_meta = []

            public = None

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Object does not exist')

        raise ItemNotFound('Version does not exist')

    update_manifest_meta(request, v_account, meta)

            public = None

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Object does not exist')

        raise ItemNotFound('Version does not exist')

    update_manifest_meta(request, v_account, meta)

            raise Forbidden('Not allowed')

        except ValueError:

            raise BadRequest('Invalid X-Object-Manifest header')

            raise ItemNotFound('Container does not exist')

        try:

                hashmaps.append(h)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Object does not exist')

            raise ItemNotFound('Version does not exist')

    else:

        try:

            hashmaps.append(h)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Object does not exist')

            raise ItemNotFound('Version does not exist')

    # Reply with the hashmap.

        raise Forbidden('Not allowed')

    except IndexError, e:

        raise Conflict(simple_list_response(request, e.data))

        raise ItemNotFound('Container does not exist')

    except ValueError:

        raise BadRequest('Invalid sharing header')

                                                v_container, v_object, public)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Object does not exist')

    response = HttpResponse(status=201)

                        file.hashmap, checksum, 'pithos', {}, True)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container does not exist')

    except QuotaError:

        raise RequestEntityTooLarge('Quota exceeded')

                                            v_container, v_object, 'pithos', src_version)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container or object does not exist')

        validate_matching_preconditions(request, meta)

                                                    v_container, v_object, 'pithos')

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Container or object does not exist')

        validate_matching_preconditions(request, meta)

                                                    v_container, v_object, 'pithos')

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Object does not exist')

    # Evaluate conditions.

                                v_account, v_container, v_object, permissions)

            except NotAllowedError:

                raise Forbidden('Not allowed')

                raise ItemNotFound('Object does not exist')

            except ValueError:

                raise BadRequest('Invalid sharing header')

                                                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, 'pithos', meta, replace)

            except NotAllowedError:

                raise Forbidden('Not allowed')

                raise ItemNotFound('Object does not exist')        

            response['X-Object-Version'] = version_id

                                            v_account, v_container, v_object)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Object does not exist')

    offset, length, total = ranges

                                        src_account, src_container, src_name, src_version)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Source object does not exist')

        if length is None:

                        hashmap, checksum, 'pithos', meta, replace, permissions)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container does not exist')

    except ValueError:

        raise BadRequest('Invalid sharing header')

                                                v_container, v_object, public)

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Object does not exist')

    response = HttpResponse(status=204)

                                        v_object, until, delimiter=delimiter)

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Object does not exist')

    return HttpResponse(status=204)

                                    SERVICE_TOKEN, COOKIE_NAME)

from pithos.backends import connect_backend

import logging

import re

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

    except NotAllowedError:

        raise Forbidden('Not allowed')

        raise ItemNotFound('Container or object does not exist')

    except ValueError:

        raise BadRequest('Invalid sharing header')

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

        except NotAllowedError:

            raise Forbidden('Not allowed')

            raise ItemNotFound('Object does not exist')

    return version_id

                self.block_hash = self.hashmaps[self.file_index][self.block_index]

                try:

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

                    raise ItemNotFound('Block does not exist')

            # Get the data from the block.

class QuotaError(Exception):

    pass

class BaseBackend(object):

    """Abstract backend class that serves as a reference for actual implementations.

        Raises:

            NotAllowedError: Operation not permitted

        """

        return

        Raises:

            NotAllowedError: Operation not permitted

        """

        return []

        Raises:

            NotAllowedError: Operation not permitted

        """

        return {}

        Raises:

            NotAllowedError: Operation not permitted

        """

        return

        Raises:

            NotAllowedError: Operation not permitted

        """

        return {}

        Raises:

            NotAllowedError: Operation not permitted

            ValueError: Invalid policy defined

        """

        Raises:

            NotAllowedError: Operation not permitted

            ValueError: Invalid policy defined

        """

        Raises:

            NotAllowedError: Operation not permitted

        """

        return

        Raises:

            NotAllowedError: Operation not permitted

        """

        return []

        Raises:

            NotAllowedError: Operation not permitted

        """

        return []

        Raises:

            NotAllowedError: Operation not permitted

        """

        return {}

        Raises:

            NotAllowedError: Operation not permitted

        """

        return ''

        Raises:

            NotAllowedError: Operation not permitted

        """

        return {}

        Raises:

            NotAllowedError: Operation not permitted

            ValueError: Invalid users/groups in permissions

        """

        Raises:

            NotAllowedError: Operation not permitted

        """

        return None

        Raises:

            NotAllowedError: Operation not permitted

        """

        return

        Raises:

            NotAllowedError: Operation not permitted

        """

        return 0, []

        Raises:

            NotAllowedError: Operation not permitted

            ValueError: Invalid users/groups in permissions

        Raises:

            NotAllowedError: Operation not permitted

            ValueError: Invalid users/groups in permissions

        Raises:

            NotAllowedError: Operation not permitted

            ValueError: Invalid users/groups in permissions

        Raises:

            NotAllowedError: Operation not permitted

        """

        return

        """Return a block's data.

        Raises:

        """

        return ''

import hashlib

import binascii

# Stripped-down version of the HashMap class found in tools.

class HashMap(list):

            raise NotAllowedError

        node = self.node.node_lookup(account)

        if node is not None:

        if policy:

            self._check_policy(policy)

        node = self._put_path(user, self.ROOTNODE, account)

        if node is None:

            return

        if not self.node.node_remove(node):

        self.permissions.group_destroy(account)

    @backend_method

        except NameError:

            pass

        else:

        if policy:

            self._check_policy(policy)

        path = '/'.join((account, container))

            return

        if self._get_statistics(node)[0] > 0:

        hashes, size = self.node.node_purge_children(node, inf, CLUSTER_HISTORY)

        for h in hashes:

            self.store.map_delete(h)

            except NameError: # Object may be deleted.

                del_props = self.node.version_lookup(node, inf, CLUSTER_DELETED)

                if del_props is None:

                modified = del_props[self.MTIME]

        meta = {}

        logger.debug("get_block: %s", hash)

        block = self.store.block_get(binascii.unhexlify(hash))

        if not block:

        return block

    @backend_method(autocommit=0)

        path = '/'.join((account, container))

        node = self.node.node_lookup(path)

        if node is None:

        return path, node

    def _lookup_object(self, account, container, name):

        path = '/'.join((account, container, name))

        node = self.node.node_lookup(path)

        if node is None:

        return path, node

    def _lookup_objects(self, paths):

        return paths, nodes

    def _get_properties(self, node, until=None):

        if props is None and until is not None:

            props = self.node.version_lookup(node, before, CLUSTER_HISTORY)

        if props is None:

        return props

    def _get_statistics(self, node, until=None):

        if version is None:

            props = self.node.version_lookup(node, inf, CLUSTER_NORMAL)

            if props is None:

        else:

            try:

                version = int(version)

            except ValueError:

            props = self.node.version_get_properties(version)

            if props is None or props[self.CLUSTER] == CLUSTER_DELETED:

        return props

    def _put_version_duplicate(self, user, node, src_node=None, size=None, type=None, hash=None, checksum=None, cluster=CLUSTER_NORMAL, is_copy=False):

        """Create a new version of the node."""