Synnefo

logger = logging.getLogger(__name__)

def debug_method(func):

    @wraps(func)

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

        self.lock_container_path = False

    def pre_exec(self, lock_container_path=False):

        self.lock_container_path = lock_container_path

        self.wrapper.execute()

    def post_exec(self, success_status=True):

        if success_status:

                self.commission_serials.delete_many(

                    r['rejected'])

            self.wrapper.rollback()

    def close(self):

        self.wrapper.close()

        return not isinstance(self.astakosclient, DisabledAstakosClient)

    @debug_method

    def list_accounts(self, user, marker=None, limit=10000):

        """Return a list of accounts the user can access."""

        return allowed[start:start + limit]

    @debug_method

    def get_account_meta(

            self, user, account, domain, until=None, include_user_defined=True,

            external_quota=None):

        return meta

    @debug_method

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

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

                           update_statistics_ancestors_depth=-1)

    @debug_method

    def get_account_groups(self, user, account):

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

        return self.permissions.group_dict(account)

    @debug_method

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

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

                self.permissions.group_addmany(account, k, v)

    @debug_method

    def get_account_policy(self, user, account, external_quota=None):

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

        return policy

    @debug_method

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

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

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

    @debug_method

    def put_account(self, user, account, policy=None):

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

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

    @debug_method

    def delete_account(self, user, account):

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

        self.permissions.group_destroy(account)

    @debug_method

    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."""

        return containers[start:start + limit]

    @debug_method

    def list_container_meta(self, user, account, container, domain,

                            until=None):

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

                                               CLUSTER_DELETED, allowed)

    @debug_method

    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."""

        return meta

    @debug_method

    def update_container_meta(self, user, account, container, domain, meta,

                              replace=False):

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

                                         update_statistics_ancestors_depth=0)

    @debug_method

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

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

        return self._get_policy(node, is_account_policy=False)

    @debug_method

    def update_container_policy(self, user, account, container, policy,

                                replace=False):

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

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

    @debug_method

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

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

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

    @debug_method

    def delete_container(self, user, account, container, until=None, prefix='',

                         delimiter=None):

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

        return allowed

    @debug_method

    def list_objects(self, user, account, container, prefix='', delimiter=None,

                     marker=None, limit=10000, virtual=True, domain=None,

                     keys=None, shared=False, until=None, size_range=None,

            virtual, domain, keys, shared, until, size_range, False, public)

    @debug_method

    def list_object_meta(self, user, account, container, prefix='',

                         delimiter=None, marker=None, limit=10000,

                         virtual=True, domain=None, keys=None, shared=False,

        return objects

    @debug_method

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

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

                                             True, False)

    @debug_method

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

        """Return a mapping of object paths to public ids under a container."""

        return public

    @debug_method

    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."""

        return meta

    @debug_method

    def update_object_meta(self, user, account, container, name, domain, meta,

                           replace=False):

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

        return dest_version_id

    @debug_method

    def get_object_permissions_bulk(self, user, account, container, names):

        """Return the action allowed on the object, the path

        from which the object gets its permissions from,

        return nobject_permissions

    @debug_method

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

        """Return the action allowed on the object, the path

        from which the object gets its permissions from,

                self.permissions.access_get(permissions_path))

    @debug_method

    def update_object_permissions(self, user, account, container, name,

                                  permissions):

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

                                        self.permissions.access_members(path)})

    @debug_method

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

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

        return p

    @debug_method

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

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

                path, self.public_url_security, self.public_url_alphabet)

    @debug_method

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

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

        return dest_version_id, hexlified

    @debug_method

    def update_object_checksum(self, user, account, container, name, version,

                               checksum):

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

                dest_version_ids)

    @debug_method

    def copy_object(self, user, src_account, src_container, src_name,

                    dest_account, dest_container, dest_name, type, domain,

                    meta=None, replace_meta=False, permissions=None,

        return dest_version_id

    @debug_method

    def move_object(self, user, src_account, src_container, src_name,

                    dest_account, dest_container, dest_name, type, domain,

                    meta=None, replace_meta=False, permissions=None,

            self.permissions.access_clear_bulk(paths)

    @debug_method

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

                      prefix='', delimiter=None):

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

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

    @debug_method

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

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

                x[self.CLUSTER] != CLUSTER_DELETED]

    @debug_method

    def get_uuid(self, user, uuid):

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

        return (account, container, name)

    @debug_method

    def get_public(self, user, public):

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

    # Reporting functions.

    @debug_method

    def _report_size_change(self, user, account, size, details=None):

        details = details or {}

            self.serials.append(serial)

    @debug_method

    def _report_object_change(self, user, account, path, details=None):

        details = details or {}

        details.update({'user': user})

                              details))

    @debug_method

    def _report_sharing_change(self, user, account, path, details=None):

        details = details or {}

        details.update({'user': user})

    # Domain functions

    @debug_method

    def get_domain_objects(self, domain, user=None):

        allowed_paths = self.permissions.access_list_paths(

            user, include_owned=user is not None, include_containers=False)