Synnefo

# or implied, of GRNET S.A.

import sys

import uuid as uuidlib

import logging

import hashlib

from synnefo.lib.quotaholder import QuotaholderClient

# Stripped-down version of the HashMap class found in tools.

                 quotaholder_client_poolsize=None,

                 free_versioning=True, block_params=None,

                 public_url_security=None,

        db_module = db_module or DEFAULT_DB_MODULE

        db_connection = db_connection or DEFAULT_DB_CONNECTION

        block_module = block_module or DEFAULT_BLOCK_MODULE

        block_umask = block_umask or DEFAULT_BLOCK_UMASK

        block_params = block_params or DEFAULT_BLOCK_PARAMS

        #queue_module = queue_module or DEFAULT_QUEUE_MODULE

        #queue_hosts = queue_hosts or DEFAULT_QUEUE_HOSTS

        #queue_exchange = queue_exchange or DEFAULT_QUEUE_EXCHANGE

        self.block_size = 4 * 1024 * 1024  # 4MB

        self.free_versioning = free_versioning

        def load_module(m):

            __import__(m)

            return sys.modules[m]

                raise NotAllowedError

            return {}

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

        if self.using_external_quotaholder:

            external_quota = external_quota or {}

            policy['quota'] = external_quota.get('maxValue', 0)

        if user != account:

            raise NotAllowedError

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

    @backend_method

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

        if node is not None:

            raise AccountExists('Account already exists')

        if policy:

        node = self._put_path(user, self.ROOTNODE, account)

    @backend_method

    def delete_account(self, user, account):

        src_version_id, dest_version_id = self._put_metadata(

            user, node, domain, meta, replace)

        if src_version_id is not None:

            if versioning != 'auto':

                self.node.version_remove(src_version_id)

                raise NotAllowedError

            return {}

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

    @backend_method

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

        if user != account:

            raise NotAllowedError

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

    @backend_method

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

        else:

            raise ContainerExists('Container already exists')

        if policy:

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

        node = self._put_path(

            user, self._lookup_account(account, True)[1], path)

    @backend_method

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

        size_delta = size - del_size

        if not self.using_external_quotaholder: # Check account quota.

            if size_delta > 0:

                account_usage = self._get_statistics(account_node)[1] + size_delta

                if (account_quota > 0 and account_usage > account_quota):

                    raise QuotaError('account quota exceeded: limit: %s, usage: %s' % (

                    ))

        # Check container quota.

        container_usage = self._get_statistics(container_node)[1] + size_delta

        if (container_quota > 0 and container_usage > container_quota):

            # This must be executed in a transaction, so the version is

    # Policy functions.

        for k in policy.keys():

            if policy[k] == '':

        for k, v in policy.iteritems():

            if k == 'quota':

                q = int(v)  # May raise ValueError.

            else:

                raise ValueError

        if replace:

                if k not in policy:

                    policy[k] = v

        self.node.policy_set(node, policy)

        policy.update(self.node.policy_get(node))

        return policy

        if version_id is None:

            return 0

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

        if versioning != 'auto':

            hash, size = self.node.version_remove(version_id)

            self.store.map_delete(hash)