Synnefo » Pithos

        else:

            meta = {}

            if props is not None:

            if until is not None:

                meta.update({'until_timestamp': tstamp})

            meta.update({'name': account, 'count': count, 'bytes': bytes})

        if user != account:

            raise NotAllowedError

        path, node = self._lookup_account(account, True)

    @backend_method

    def get_account_groups(self, user, account):

            start, limit = self._list_limits(allowed, marker, limit)

            return allowed[start:start + limit]

        node = self.node.node_lookup(account)

    @backend_method

    def get_container_meta(self, user, account, container, domain, until=None):

        if user != account:

            meta = {'name': container}

        else:

            if until is not None:

                meta.update({'until_timestamp': tstamp})

            meta.update({'name': container, 'count': count, 'bytes': bytes})

        if user != account:

            raise NotAllowedError

        path, node = self._lookup_container(account, container)

    @backend_method

    def get_container_policy(self, user, account, container):

                if not allowed:

                    return []

        path, node = self._lookup_container(account, container)

    @backend_method

    def list_object_meta(self, user, account, container, domain, until=None):

                raise NotAllowedError

        path, node = self._lookup_container(account, container)

        before = until if until is not None else inf

    @backend_method

    def get_object_meta(self, user, account, container, name, domain, version=None):

                    raise NameError('Object does not exist')

                modified = del_props[self.MTIME]

        meta.update({'name': name, 'bytes': props[self.SIZE], 'hash':props[self.HASH]})

        meta.update({'version': props[self.SERIAL], 'version_timestamp': props[self.MTIME]})

        meta.update({'modified': modified, 'modified_by': props[self.MUSER]})

        logger.debug("update_object_meta: %s %s %s %s %s %s", account, container, name, domain, meta, replace)

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

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

        self._apply_versioning(account, container, src_version_id)

        return dest_version_id

        hashmap = self.store.map_get(binascii.unhexlify(props[self.HASH]))

        return props[self.SIZE], [binascii.hexlify(x) for x in hashmap]

        if permissions is not None and user != account:

            raise NotAllowedError

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

                # This must be executed in a transaction, so the version is never created if it fails.

                raise QuotaError

        if permissions is not None:

            self.permissions.access_set(path, permissions)

        self._apply_versioning(account, container, src_version_id)

    @backend_method

    def update_object_hashmap(self, user, account, container, name, size, hashmap, domain, meta={}, replace_meta=False, permissions=None):

            raise ie

        hash = map.hash()

        self.store.map_put(hash, map)

        return dest_version_id

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

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

        props = self._get_version(node, src_version)

        hash = props[self.HASH]

        size = props[self.SIZE]

        return dest_version_id

    @backend_method

        """Copy an object's data and metadata."""

        logger.debug("copy_object: %s %s %s %s %s %s %s %s %s %s %s", src_account, src_container, src_name, dest_account, dest_container, dest_name, domain, meta, replace_meta, permissions, src_version)

    @backend_method

    def move_object(self, user, src_account, src_container, src_name, dest_account, dest_container, dest_name, domain, meta={}, replace_meta=False, permissions=None):

        logger.debug("move_object: %s %s %s %s %s %s %s %s %s %s", src_account, src_container, src_name, dest_account, dest_container, dest_name, domain, meta, replace_meta, permissions)

        if user != src_account:

            raise NotAllowedError

        if (src_account, src_container, src_name) != (dest_account, dest_container, dest_name):

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

        return dest_version_id

        dest_version_id, mtime = self.node.version_create(node, hash, size, src_version_id, user, cluster)

        return src_version_id, dest_version_id

        """Create a new version and store metadata."""

        src_version_id, dest_version_id = self._put_version_duplicate(user, node)

        return src_version_id, dest_version_id

    def _list_limits(self, listing, marker, limit):

            limit = 10000

        return start, limit

        cont_prefix = path + '/'

        prefix = cont_prefix + prefix

        start = cont_prefix + marker if marker else None

        before = until if until is not None else inf

        objects.extend([(p, None) for p in prefixes] if virtual else [])

        objects.sort(key=lambda x: x[0])

        objects = [(x[0][len(cont_prefix):], x[1]) for x in objects]