Synnefo

logger = logging.getLogger(__name__)

class SimpleBackend(BaseBackend):

    """A simple backend.

                  'namelen': self.blocker.hashlen}

        self.mapper = Mapper(**params)

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

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

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

        return meta

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

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

            raise NotAllowedError

        self._put_metadata(user, account, meta, replace, False)

    def get_account_groups(self, user, account):

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

            raise NotAllowedError

        return self._get_groups(account)

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

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

        self._check_groups(groups)

        self._put_groups(account, groups, replace)

    def put_account(self, user, account):

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

        else:

            raise NameError('Account already exists')

        version_id = self._put_version(account, user)

    def delete_account(self, user, account):

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

        sql = 'delete from versions where name = ?'

        self.con.execute(sql, (account,))

        self._del_groups(account)

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

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

            return containers[start:start + limit]

        return self._list_objects(account, '', '/', marker, limit, False, [], until)

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

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

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

        return meta

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

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

        path, version_id, mtime = self._get_containerinfo(account, container)

        self._put_metadata(user, path, meta, replace, False)

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

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

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

        return self._get_policy(path)

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

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

        for k, v in policy.iteritems():

            sql = 'insert or replace into policy (name, key, value) values (?, ?, ?)'

            self.con.execute(sql, (path, k, v))

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

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

        for k, v in policy.iteritems():

            sql = 'insert or replace into policy (name, key, value) values (?, ?, ?)'

            self.con.execute(sql, (path, k, v))

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

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

            c = self.con.execute(sql, (path + '/%', until))

            for v in [x[0] for x in c.fetchall()]:

                self._del_version(v)

            return

        count = self._get_pathstats(path)[0]

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

        self._copy_version(user, account, account, True, False) # New account version (for timestamp update).

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

        """Return a list of objects existing under a container."""

        path, version_id, mtime = self._get_containerinfo(account, container, until)

        return self._list_objects(path, prefix, delimiter, marker, limit, virtual, keys, until)

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

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

        c = self.con.execute(sql, (path + '/%',))

        return [x[0] for x in c.fetchall()]

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

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

        meta.update({'modified': modified, 'modified_by': muser})

        return meta

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

        """Update the metadata associated with the object."""

        path, version_id, muser, mtime, size = self._get_objectinfo(account, container, name)

        self._put_metadata(user, path, meta, replace)

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

        """Return the path from which this object gets its permissions from,\

        along with a dictionary containing the permissions."""

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

        return self._get_permissions(path)

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

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

        r, w = self._check_permissions(path, permissions)

        self._put_permissions(path, r, w)

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

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

            return '/public/' + path

        return None

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

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

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

        self._put_public(path, public)

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

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

        hashmap = self.mapper.map_retr(version_id)

        return size, [binascii.hexlify(x) for x in hashmap]

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

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

            self.con.execute(sql, (dest_version_id, k, v))

        if permissions is not None:

            self._put_permissions(path, r, w)

    def copy_object(self, user, account, src_container, src_name, dest_container, dest_name, dest_meta={}, replace_meta=False, permissions=None, src_version=None):

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

            self.con.execute(sql, (dest_version_id, k, v))

        if permissions is not None:

            self._put_permissions(dest_path, r, w)

    def move_object(self, user, account, src_container, src_name, dest_container, dest_name, dest_meta={}, replace_meta=False, permissions=None):

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

        self.copy_object(user, account, src_container, src_name, dest_container, dest_name, dest_meta, replace_meta, permissions, None)

        self.delete_object(user, account, src_container, src_name)

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

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

                pass

            else:

                self._del_sharing(path)

            return

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

        self._put_version(path, user, 0, 1)

        self._del_sharing(path)

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

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

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

        return [(int(x[0]), int(x[1])) for x in c.fetchall()]

    def get_block(self, hash):

        """Return a block's data."""

            raise NameError('Block does not exist')

        return blocks[0]

    def put_block(self, data):

        """Create a block and return the hash."""

        hashes, absent = self.blocker.block_stor((data,))

        return binascii.hexlify(hashes[0])

    def update_block(self, hash, data, offset=0):

        """Update a known block and return the hash."""

        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

        return str(id)

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

            # TODO: Copy properly.

            hashmap = self.mapper.map_retr(src_version_id)

            self.mapper.map_stor(dest_version_id, hashmap)

        return src_version_id, dest_version_id

    def _get_versioninfo(self, account, container, name, until=None):

            else:

                sql = 'insert or replace into metadata (version_id, key, value) values (?, ?, ?)'

                self.con.execute(sql, (dest_version_id, k, v))

    def _check_policy(self, policy):

        for k in policy.keys():

            if v:

                sql = 'insert into groups (account, gname, user) values (?, ?, ?)'

                self.con.executemany(sql, [(account, k, x) for x in v])

    def _del_groups(self, account):

        sql = 'delete from groups where account = ?'

            self.con.executemany(sql, [(path, 'read', x) for x in r])

        if w:

            self.con.executemany(sql, [(path, 'write', x) for x in w])

    def _get_public(self, path):

        sql = 'select name from public where name = ?'

        else:

            sql = 'insert or replace into public (name) values (?)'

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

    def _del_sharing(self, path):

        sql = 'delete from permissions where name = ?'

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

        sql = 'delete from public where name = ?'

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

    def _is_allowed(self, user, account, container, name, op='read'):

        if user == account: