Synnefo

    return HttpResponse(status=ret)

def container_update(request, v_account, v_container):

    # Normal Response Codes: 202

    # Error Response Codes: internalServerError (500),

    return response

def container_delete(request, v_account, v_container):

    # Normal Response Codes: 204

    # Error Response Codes: internalServerError (500),

    return response

def object_copy(request, v_account, v_container, v_object):

    # Normal Response Codes: 201

    # Error Response Codes: internalServerError (500),

                # Add a PithosBackend as attribute of the request object

                request.backend = get_backend(backend_cls)

                path = strip_prefix(request.path)

                assert path is not None, 'Unexpected path: %s' % request.path

        self.lock_container_path = False

        self.serials = []

        self.messages = []

        self.lock_container_path = lock_container_path

        self.wrapper.execute()

    def post_exec(self, success_status=True):

        if success_status:

            # send messages produced

        self.wrapper.close()

        self.queue.close()

    @property

    def using_external_quotaholder(self):

        return not isinstance(self.astakosclient, DisabledAstakosClient)

                raise NotAllowedError

            allowed = self.permissions.access_list_paths(

                user, '/'.join((account, container)))

        before = until if until is not None else inf

        allowed = self._get_formatted_paths(allowed)

        return self.node.latest_attribute_keys(node, domain, before,

        if user != account:

            if until:

                raise NotAllowedError

        props = self._get_properties(node, until)

        mtime = props[self.MTIME]

        count, bytes, tstamp = self._get_statistics(node, until)

        """Update the metadata associated with the container for the domain."""

        self.can_write(user, account, container)

        src_version_id, dest_version_id = self._put_metadata(

            user, node, domain, meta, replace,

            update_statistics_ancestors_depth=0)

        self.can_read(user, account, container)

        if user != account:

            return {}

        return self._get_policy(node, is_account_policy=False)

    @debug_method

        """Update the policy associated with the container."""

        self.can_write(user, account, container)

        self._check_policy(policy, is_account_policy=False)

        self._put_policy(node, policy, replace, is_account_policy=False)

        self.can_write(user, account, container)

        policy = policy or {}

        try:

        except NameError:

            pass

        else:

        """Delete/purge the container with the given name."""

        self.can_write(user, account, container)

        if until is not None:

            hashes, size, serials = self.node.node_purge_children(

                user, account, container, prefix, shared=True, public=False)

            objects = set()

            if shared_paths:

                shared_paths = self._get_formatted_paths(shared_paths)

                objects |= set(self._list_object_properties(

                    node, path, prefix, delimiter, marker, limit, virtual,

            user, account, container, prefix, shared, public)

        if shared and not allowed:

            return []

        allowed = self._get_formatted_paths(allowed)

        objects = self._list_object_properties(

            node, path, prefix, delimiter, marker, limit, virtual, domain,

        self.permissions.access_set(path, permissions)

        self._report_sharing_change(user, account, path, {'members':

                                    self.permissions.access_members(path)})

    @debug_method

    def get_object_public(self, user, account, container, name):

            self._check_permissions(path, permissions)

        account_path, account_node = self._lookup_account(account, True)

            account, container)

        path, node = self._put_object_node(

        self.can_write(user, account, container, name)

        # Update objects with greater version and same hashmap

        # and size (fix metadata updates).

        path, node = self._lookup_object(account, container, name)

        props = self._get_version(node, version)

        versions = self.node.node_get_versions(node)

        report_size_change = not is_move

        dest_meta = dest_meta or {}

        dest_version_ids = []

        path, node = self._lookup_object(src_account, src_container, src_name)

        # TODO: Will do another fetch of the properties in duplicate version...

        props = self._get_version(

        self.can_read(user, src_account, src_container, src_name)

        self.can_write(user, dest_account, dest_container, dest_name)

        meta = meta or {}

        dest_version_id = self._copy_object(

            user, src_account, src_container, src_name, dest_account,

        self.can_read(user, src_account, src_container, src_name)

        self.can_write(user, dest_account, dest_container, dest_name)

        meta = meta or {}

        if user != src_account:

            raise NotAllowedError

            raise NameError

        path, serial = info

        account, container, name = path.split('/', 2)

        return (account, container, name)

    def get_block(self, hash):

                update_statistics_ancestors_depth=-1)  # User is account.

        return account, node

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

        node = self.node.node_lookup(path, for_update)

        if node is None:

            raise ItemNotExists('Container does not exist')

        return path, node

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

        if version_id is None:

            return 0

        versioning = self._get_policy(

            node, is_account_policy=False)['versioning']

        if versioning != 'auto':

                        return p

        return None

    def can_read(self, user, account, container=None, name=None):

        if path in self.read_allowed[user]:

            return

        self._can_read(user, account, container, name)

        self.read_allowed[user].append(path)

    def can_write(self, user, account, container=None, name=None):

        if path in self.write_allowed[user]:

            return True

        self._can_write(user, account, container, name)