Synnefo

    Uses SQLite for storage.

    """

    def __init__(self, db):

        self.hash_algorithm = 'sha256'

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

        if user != account:

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

                raise NotAllowedError

        try:

            version_id, mtime = self._get_accountinfo(account, until)

        except NameError:

            version_id = None

            mtime = 0

        count, bytes, tstamp = self._get_pathstats(account, until)

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

            if until is not None:

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

        return meta

    @backend_method

            if account not in self._allowed_accounts(user):

                raise NotAllowedError

            return {}

        return self._get_groups(account)

    @backend_method

        logger.debug("update_account_groups: %s %s %s", account, groups, replace)

        if user != account:

            raise NotAllowedError

        self._check_groups(groups)

        self._put_groups(account, groups, replace)

            pass

        else:

            raise NameError('Account already exists')

    @backend_method

    def delete_account(self, user, account):

        if policy:

            self._check_policy(policy)

        path = os.path.join(account, container)

        for k, v in self.default_policy.iteritems():

            if k not in policy:

                policy[k] = v

        tstamp = int(time.time())

        sql = 'insert into versions (name, user, tstamp, size, hide) values (?, ?, ?, ?, ?)'

        id = self.con.execute(sql, (path, user, tstamp, size, hide)).lastrowid

    def _copy_version(self, user, src_path, dest_path, copy_meta=True, copy_data=True, src_version=None):

        if src_version is not None:

                size = 0

        if not copy_data:

            size = 0

        if copy_meta and src_version_id is not None:

            sql = 'insert into metadata select %s, key, value from metadata where version_id = ?'

            sql = sql % dest_version_id

        version_id, muser, mtime, size = self._get_version(path, version)

        return path, version_id, muser, mtime, size

    def _get_metadata(self, path, version):

        sql = 'select key, value from metadata where version_id = ?'

        c = self.con.execute(sql, (version,))

        c = self.con.execute(sql, (path,))

        return dict(c.fetchall())

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

        start = 0

        if marker: