Synnefo

import hashlib

import binascii

from functools import wraps, partial

from traceback import format_exc

    return wrapper

def list_method(func):

    @wraps(func)

    def wrapper(self, *args, **kw):

        self.in_transaction = False

    def pre_exec(self, lock_container_path=False):

        self.lock_container_path = lock_container_path

        self.wrapper.execute()

        self.serials = []

        self.in_transaction = True

    def post_exec(self, success_status=True):

                         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:

                raise NotAllowedError

        try:

            props = self._get_properties(node, until)

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

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

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

        self._put_metadata(user, node, domain, meta, replace,

                           update_statistics_ancestors_depth=-1)

    def get_account_groups(self, user, account):

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

        if user != account:

            return {}

        self._lookup_account(account, True)

        return self.permissions.group_dict(account)

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

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

        self._lookup_account(account, True)

        self._check_groups(groups)

        if replace:

    def get_account_policy(self, user, account):

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

        if user != account:

            return {}

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

        policy = self._get_policy(node, is_account_policy=True)

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

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

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

        self._check_policy(policy, is_account_policy=True)

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

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

        policy = policy or {}

        node = self.node.node_lookup(account)

        if node is not None:

            raise AccountExists('Account already exists')

    def delete_account(self, user, account):

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

        node = self.node.node_lookup(account)

        if node is None:

            return

            raise AccountNotEmpty('Account is not empty')

        self.permissions.group_destroy(account)

    @debug_method

    @backend_method

    @list_method

                        shared=False, until=None, public=False):

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

        if user != account:

                raise NotAllowedError

            return self._allowed_containers(user, account)

        if shared or public:

                            until=None):

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

        allowed = []

        if user != account:

            if until:

                raise NotAllowedError

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

        before = until if until is not None else inf

        allowed = self._get_formatted_paths(allowed)

                           include_user_defined=True):

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

        if user != account:

                raise NotAllowedError

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

        props = self._get_properties(node, until)

                              replace=False):

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

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

        src_version_id, dest_version_id = self._put_metadata(

            user, node, domain, meta, replace,

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

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

        if user != account:

            return {}

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

        return self._get_policy(node, is_account_policy=False)

                                replace=False):

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

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

        self._check_policy(policy, is_account_policy=False)

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

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

        policy = policy or {}

        try:

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

        except NameError:

                         delimiter=None):

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

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

        if until is not None:

                paths.append(path)

            self.permissions.access_clear_bulk(paths)

    def _list_objects(self, user, account, container, prefix, delimiter,

                      marker, limit, virtual, domain, keys, shared, until,

                      size_range, all_props, public):

                        version=None, include_user_defined=True):

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

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

        props = self._get_version(node, version)

        if version is None:

                           replace=False):

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

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

                                         lock_container=True)

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

                                        self.permissions.access_members(path)})

    @debug_method

    @backend_method

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

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

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

        p = self.permissions.public_get(path)

        return p

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

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

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

                                   lock_container=True)[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."""

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

        props = self._get_version(node, version)

        if props[self.HASH] is None:

                            is_copy=False, report_size_change=True):

        if permissions is not None and user != account:

            raise NotAllowedError

        if permissions is not None:

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

            self._check_permissions(path, permissions)

        # Update objects with greater version and same hashmap

        # and size (fix metadata updates).

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

                                         lock_container=True)

        props = self._get_version(node, version)

        report_size_change = not is_move

        dest_meta = dest_meta or {}

        dest_version_ids = []

        src_container_path = '/'.join((src_account, src_container))

        dest_container_path = '/'.join((dest_account, dest_container))

                paths.append(path)

            self.permissions.access_clear_bulk(paths)

    @debug_method

    @backend_method

    def delete_object(self, user, account, container, name, until=None,

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

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

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

        versions = self.node.node_get_versions(node)

        return [[x[self.SERIAL], x[self.MTIME]] for x in versions if

        path, serial = info

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

        if check_permissions:

        return (account, container, name)

    @debug_method

        if path is None:

            raise NameError

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

        return (account, container, name)

    def get_block(self, hash):

        return None

        if user == account:

            return True

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

                self.permissions.access_check(path, self.WRITE, user)):

            raise NotAllowedError

        if user == account:

            return True

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

    def _allowed_accounts(self, user):

        allow = set()

        for path in self.permissions.access_list_paths(user):

        return sorted(allow)

    def _allowed_containers(self, user, account):

        allow = set()

        for path in self.permissions.access_list_paths(user, account):

        return sorted(allow)

    # Domain functions