Synnefo

    def get_account_meta(self, user, account, domain, until=None, include_user_defined=True):

        """Return a dictionary with the account metadata for the domain."""

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

        if user != account:

            if until or node is None or account not in self._allowed_accounts(user):

    def update_account_meta(self, user, account, domain, meta, replace=False):

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

        if user != account:

            raise NotAllowedError

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

    def get_account_groups(self, user, account):

        """Return a dictionary with the user groups defined for this account."""

        if user != account:

            if account not in self._allowed_accounts(user):

                raise NotAllowedError

    def update_account_groups(self, user, account, groups, replace=False):

        """Update the groups associated with the account."""

        if user != account:

            raise NotAllowedError

        self._lookup_account(account, True)

    def get_account_policy(self, user, account):

        """Return a dictionary with the account policy."""

        if user != account:

            if account not in self._allowed_accounts(user):

                raise NotAllowedError

    def update_account_policy(self, user, account, policy, replace=False):

        """Update the policy associated with the account."""

        if user != account:

            raise NotAllowedError

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

    def put_account(self, user, account, policy={}):

        """Create a new account with the given name."""

        if user != account:

            raise NotAllowedError

        node = self.node.node_lookup(account)

    def delete_account(self, user, account):

        """Delete the account with the given name."""

        if user != account:

            raise NotAllowedError

        node = self.node.node_lookup(account)

    def list_containers(self, user, account, marker=None, limit=10000, shared=False, until=None, public=False):

        """Return a list of containers existing under an account."""

        if user != account:

            if until or account not in self._allowed_accounts(user):

                raise NotAllowedError

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

        """Return a list with all the container's object meta keys for the domain."""

        allowed = []

        if user != account:

            if until:

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

        """Return a dictionary with the container metadata for the domain."""

        if user != account:

            if until or container not in self._allowed_containers(user, account):

                raise NotAllowedError

    def update_container_meta(self, user, account, container, domain, meta, replace=False):

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

        if user != account:

            raise NotAllowedError

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

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

        """Return a dictionary with the container policy."""

        if user != account:

            if container not in self._allowed_containers(user, account):

                raise NotAllowedError

    def update_container_policy(self, user, account, container, policy, replace=False):

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

        if user != account:

            raise NotAllowedError

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

    def put_container(self, user, account, container, policy={}):

        """Create a new container with the given name."""

        if user != account:

            raise NotAllowedError

        try:

        self._put_policy(node, policy, True)

    @backend_method

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

        if user != account:

            raise NotAllowedError

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

    def list_objects(self, user, account, container, prefix='', delimiter=None, marker=None, limit=10000, virtual=True, domain=None, keys=[], shared=False, until=None, size_range=None, public=False):

        """Return a list of object (name, version_id) tuples existing under a container."""

        return self._list_objects(user, account, container, prefix, delimiter, marker, limit, virtual, domain, keys, shared, until, size_range, False, public)

    @backend_method

    def list_object_meta(self, user, account, container, prefix='', delimiter=None, marker=None, limit=10000, virtual=True, domain=None, keys=[], shared=False, until=None, size_range=None, public=False):

        """Return a list of object metadata dicts existing under a container."""

        props = self._list_objects(user, account, container, prefix, delimiter, marker, limit, virtual, domain, keys, shared, until, size_range, True, public)

        objects = []

        for p in props:

    def list_object_permissions(self, user, account, container, prefix=''):

        """Return a list of paths that enforce permissions under a container."""

        return self._list_object_permissions(user, account, container, prefix, True, False)

    @backend_method

    def list_object_public(self, user, account, container, prefix=''):

        """Return a dict mapping paths to public ids for objects that are public under a container."""

        public = {}

        for path, p in self.permissions.public_list('/'.join((account, container, prefix))):

            public[path] = p + ULTIMATE_ANSWER

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

        """Return a dictionary with the object metadata for the domain."""

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

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

        props = self._get_version(node, version)

    def update_object_meta(self, user, account, container, name, domain, meta, replace=False):

        """Update the metadata associated with the object for the domain and return the new version."""

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

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

        src_version_id, dest_version_id = self._put_metadata(user, node, domain, meta, replace)

        from which the object gets its permissions from,

        along with a dictionary containing the permissions."""

        allowed = 'write'

        permissions_path = self._get_permissions_path(account, container, name)

        if user != account:

    def update_object_permissions(self, user, account, container, name, permissions):

        """Update the permissions associated with the object."""

        if user != account:

            raise NotAllowedError

        path = self._lookup_object(account, container, name)[0]

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

        """Return the public id of the object if applicable."""

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

        path = self._lookup_object(account, container, name)[0]

        p = self.permissions.public_get(path)

    def update_object_public(self, user, account, container, name, public):

        """Update the public status of the object."""

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

        path = self._lookup_object(account, container, name)[0]

        if not public:

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

        """Return the object's size and a list with partial hashes."""

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

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

        props = self._get_version(node, version)

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

        """Create/update an object with the specified size and partial hashes."""

        if size == 0: # No such thing as an empty hashmap.

            hashmap = [self.put_block('')]

        map = HashMap(self.block_size, self.hash_algorithm)

    def update_object_checksum(self, user, account, container, name, version, checksum):

        """Update an object's checksum."""

        # Update objects with greater version and same hashmap and size (fix metadata updates).

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

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

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

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

        dest_version_id = self._copy_object(user, src_account, src_container, src_name, dest_account, dest_container, dest_name, type, domain, meta, replace_meta, permissions, src_version, False)

        return dest_version_id

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

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

        if user != src_account:

            raise NotAllowedError

        dest_version_id = self._copy_object(user, src_account, src_container, src_name, dest_account, dest_container, dest_name, type, domain, meta, replace_meta, permissions, None, True)

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

        return dest_version_id

        if user != account:

            raise NotAllowedError

        self.permissions.access_clear(path)

    @backend_method

        """Delete/purge an object."""

        self._delete_object(user, account, container, name, until)

    @backend_method

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

        """Return a list of all (version, version_timestamp) tuples for an object."""

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

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

        versions = self.node.node_get_versions(node)

    def get_uuid(self, user, uuid):

        """Return the (account, container, name) for the UUID given."""

        info = self.node.latest_uuid(uuid)

        if info is None:

            raise NameError

    def get_public(self, user, public):

        """Return the (account, container, name) for the public id given."""

        if public is None or public < ULTIMATE_ANSWER:

            raise NameError

        path = self.permissions.public_path(public - ULTIMATE_ANSWER)