Synnefo

    def node_children(self, node):

        q = "select count(node) from nodes where parent = ?"

        q = "update nodes set parent = ?, path = ? where serial = ?"

        self.execute(q, (parent, path, source))

                          "where path like ?")

#     def node_delete(self, parent, prefix,

#                     start='', delimiter=None,

#                     after=0.0, before=inf,

#                     filterq=None, versions=0,

#                     cluster=0, limit=10000):

#         """Delete the matching version for each

#            of the matching paths in the parent's namespace.

#            Return empty if nothing is deleted, else return matches.

#            The paths matching are those that would

#            be returned by .node_list() with the same arguments.

#            Note that only paths are deleted, not prefixes.

# 

#         """

#         r = self.node_list(parent, prefix,

#                            start=start, delimiter=delimiter,

#                            after=after, before=before,

#                            filterq=filterq, versions=versions,

#                            cluster=cluster, limit=limit)

#         matches, prefixes = r

#         if not matches:

#             return ()

# 

#         q = "delete from nodes where serial = ?"

#         self.executemany(q, ((props[SERIAL],) for props in matches))

#         # TODO: Update sizes.

#         return matches

#     def node_purge(self, parent, path, after=0, before=inf, cluster=0):

#         """Delete all nodes with the specified

#            parent, cluster and path, and return

#            the serials of nodes deleted.

#         """

#         execute = self.execute

#         q = ("select count(serial), total(size), "

#                     "total(population), total(popsize) "

#              "from nodes "

#              "where parent = ? and cluster = ? "

#              "and path = ? and mtime between ? and ?")

#         args = (parent, cluster, path, after, before)

#         execute(q, args)

#         nr, size, pop, popsize = self.fetchone()

#         if not nr:

#             return ()

#         self.node_update_ancestors(parent, -pop-nr, -size-popsize)

#         q = ("select serial from nodes "

#              "where parent = ? and cluster = ? "

#              "and path = ? and mtime between ? and ?")

#         execute(q, args)

#         serials = [r[SERIAL] for r in self.fetchall()]

#         q = ("delete from nodes where "

#              "parent = ? and cluster = ? "

#              "and path = ? and mtime between ? and ?")

#         execute(q, args)

#         return serials

        node = self._lookup_account(account, user == account)

        object_count, bytes, tstamp = self._get_statistics(node, account, until)

        if mtime > tstamp:

            tstamp = mtime

            modified = self._get_statistics(node, account)[2] # Overall last modification.

            if mtime > modified:

                modified = mtime

        count = self.node.node_children(node)

        node = self._lookup_account(account, True)

        node = self.node.node_create(ROOTNODE, account)

        self.node.version_create(node, 0, None, account, CLUSTER_NORMAL)

        count = self._get_pathstats(account)[0]

        if count > 0:

        sql = 'delete from versions where name = ?'

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

    @backend_method

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

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

        logger.debug("list_containers: %s %s %s %s", account, marker, limit, until)

        if user != account:

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

                raise NotAllowedError

            allowed = self._allowed_containers(user, account)

            start, limit = self._list_limits(allowed, marker, limit)

            return allowed[start:start + limit]

        else:

            if shared:

                allowed = [x.split('/', 2)[1] for x in self.permissions.access_list_shared(account)]

                start, limit = self._list_limits(allowed, marker, limit)

                return allowed[start:start + limit]

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

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

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

        if mtime > tstamp:

            tstamp = mtime

            modified = self._get_pathstats(path)[2] # Overall last modification

            if mtime > modified:

                modified = mtime

            meta = {'name': container, 'modified': modified}

            meta = self._get_metadata(path, version_id)

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

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

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

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

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

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

        version_id = self._put_version(path, user)[0]

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

            sql = '''select version_id from versions where name like ? and tstamp <= ?

                        and version_id not in (select version_id from (%s))'''

            sql = sql % self._sql_until() # Do not delete current versions.

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

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

                self._del_version(v)

        count = self._get_pathstats(path)[0]

        if count > 0:

        sql = 'delete from versions where name = ? or name like ?' # May contain hidden items.

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

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

    @backend_method

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

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

        logger.debug("list_objects: %s %s %s %s %s %s %s %s %s %s", account, container, prefix, delimiter, marker, limit, virtual, keys, shared, until)

        allowed = []

        if user != account:

            if until:

                raise NotAllowedError

            allowed = self.permissions.access_list_paths(user, '/'.join((account, container)))

            if not allowed:

                raise NotAllowedError

        else:

            if shared:

                allowed = self.permissions.access_list_shared('/'.join((account, container)))

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

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

    @backend_method

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

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

        logger.debug("list_object_meta: %s %s %s", account, container, until)

        allowed = []

        if user != account:

            if until:

                raise NotAllowedError

            allowed = self.permissions.access_list_paths(user, '/'.join((account, container)))

            if not allowed:

                raise NotAllowedError

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

        sql = '''select distinct m.key from (%s) o, metadata m

                    where m.version_id = o.version_id and o.name like ?'''

        sql = sql % self._sql_until(until)

        param = (path + '/%',)

        if allowed:

            for x in allowed:

                sql += ' and o.name like ?'

                param += (x,)

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

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

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

            modified = mtime

            modified = self._get_version(path, version)[2] # Overall last modification

        meta = self._get_metadata(path, version_id)

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

        meta.update({'version': version_id, 'version_timestamp': mtime})

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

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

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

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

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

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

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

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

        hashmap = self.mapper.map_retr(version_id)

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

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

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

        src_version_id, dest_version_id = self._copy_version(user, path, path, not replace_meta, False)

        sql = 'update versions set size = ? where version_id = ?'

        self.con.execute(sql, (size, dest_version_id))

        for k, v in meta.iteritems():

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

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

        self._get_containerinfo(account, src_container)

        if src_version is None:

            src_path = self._get_objectinfo(account, src_container, src_name)[0]

        else:

            src_path = '/'.join((account, src_container, src_name))

        dest_path = self._get_containerinfo(account, dest_container)[0]

        dest_path = '/'.join((dest_path, dest_name))

        src_version_id, dest_version_id = self._copy_version(user, src_path, dest_path, not replace_meta, True, src_version)

        for k, v in dest_meta.iteritems():

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

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

            sql = '''select version_id from versions where name = ? and tstamp <= ?'''

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

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

                self._del_version(v)

                version_id = self._get_version(path)[0]

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

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

    @backend_method

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

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

        logger.debug("list_versions: %s %s %s", account, container, name)

        self._can_read(user, account, container, name)

        # This will even show deleted versions.

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

        sql = '''select distinct version_id, tstamp from versions where name = ? and hide = 0'''

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

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

    def _sql_until(self, until=None):

        """Return the sql to get the latest versions until the timestamp given."""

        if until is None:

            until = int(time.time())

        sql = '''select version_id, name, tstamp, size from versions v

                    where version_id = (select max(version_id) from versions

                                        where v.name = name and tstamp <= %s)

                    and hide = 0'''

        return sql % (until,)

    def _put_version(self, path, user, size=0, hide=0):

        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), tstamp

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

        """Return path, latest version, associated timestamp and size until the timestamp given."""

        p = (account, container, name)

        try:

            p = p[:p.index(None)]

        except ValueError:

            pass

        path = '/'.join(p)

        node = self.node.node_lookup(path)

        if node is not None:

            props = self.node.version_lookup(node, until, CLUSTER_NORMAL)

            # TODO: Do one lookup.

            if props is None and until is not None:

                props = self.node.version_lookup(node, until, CLUSTER_HISTORY)

            if props is not None:

                return path, props[SERIAL], props[MTIME], props[SIZE]

        raise NameError('Path does not exist')

    def _get_accountinfo(self, account, until=None):

        try:

            path, version_id, mtime, size = self._get_versioninfo(account, None, None, until)

            return version_id, mtime

        except:

            raise NameError('Account does not exist')

    def _get_containerinfo(self, account, container, until=None):

        try:

            path, version_id, mtime, size = self._get_versioninfo(account, container, None, until)

            return path, version_id, mtime

        except:

            raise NameError('Container does not exist')

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

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

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

        return path, version_id, muser, mtime, size

    def _create_account(self, user, account):

        try:

            self._get_accountinfo(account)

        except NameError:

            self._put_version(account, user)

    def _list_objects(self, path, prefix='', delimiter=None, marker=None, limit=10000, virtual=True, keys=[], until=None, allowed=[]):

        cont_prefix = path + '/'

        if keys and len(keys) > 0:

            sql = '''select distinct o.name, o.version_id from (%s) o, metadata m where o.name like ? and

                        m.version_id = o.version_id and m.key in (%s)'''

            sql = sql % (self._sql_until(until), ', '.join('?' * len(keys)))

            param = (cont_prefix + prefix + '%',) + tuple(keys)

            if allowed:

                sql += ' and (' + ' or '.join(('o.name like ?',) * len(allowed)) + ')'

                param += tuple([x + '%' for x in allowed])

            sql += ' order by o.name'

        else:

            sql = 'select name, version_id from (%s) where name like ?'

            sql = sql % self._sql_until(until)

            param = (cont_prefix + prefix + '%',)

            if allowed:

                sql += ' and (' + ' or '.join(('name like ?',) * len(allowed)) + ')'

                param += tuple([x + '%' for x in allowed])

            sql += ' order by name'

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

        objects = [(x[0][len(cont_prefix):], x[1]) for x in c.fetchall()]

        if delimiter:

            pseudo_objects = []

            for x in objects:

                pseudo_name = x[0]

                i = pseudo_name.find(delimiter, len(prefix))

                if not virtual:

                    # If the delimiter is not found, or the name ends

                    # with the delimiter's first occurence.

                    if i == -1 or len(pseudo_name) == i + len(delimiter):

                        pseudo_objects.append(x)

                else:

                    # If the delimiter is found, keep up to (and including) the delimiter.

                    if i != -1:

                        pseudo_name = pseudo_name[:i + len(delimiter)]

                    if pseudo_name not in [y[0] for y in pseudo_objects]:

                        if pseudo_name == x[0]:

                            pseudo_objects.append(x)

                        else:

                            pseudo_objects.append((pseudo_name, None))

            objects = pseudo_objects

        start, limit = self._list_limits([x[0] for x in objects], marker, limit)

        return objects[start:start + limit]

    def _del_version(self, version):

        self.mapper.map_remv(version)

        sql = 'delete from versions where version_id = ?'

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

            node = self.node.node_create(ROOTNODE, account)

            self.node.version_create(node, 0, None, account, CLUSTER_NORMAL)

        return node

        node = self.node.node_lookup('/'.join((account, container)))

        return node

        node = self.node.node_lookup('/'.join((account, container, name)))

        return node

    def _copy_version(self, user, src_node, dest_node, copy_meta=True, copy_data=True, src_version=None):

        dest_version_id, mtime = self.node.version_create(dest_node, size, src_version_id, user, CLUSTER_NORMAL)