Synnefo

    def node_get_versions(self, node, keys=(), propnames=_propnames):

        """Return the properties of all versions at node.

           If keys is empty, return all properties in the order

        """

             "from versions "

             "where node = ?")

        self.execute(q, (node,))

    def node_account_quotas(self):

        q = ("select n.path, p.value from nodes n, policy p "

             "where n.node != 0 and n.parent = 0 "

        return dict(self.execute(q).fetchall())

    def node_account_usage(self, account_node, cluster):

        select_children = ("select node from nodes where parent = ?")

        select_descedents = ("select node from nodes "

                             "where parent in (%s) "

        q = ("select sum(v.size) from versions v, nodes n "

             "where v.node = n.node "

             "and n.node in (%s) "

        qs = ("select population, size from statistics "

              "where node = ? and cluster = ?")

              "values (?, ?, ?, ?, ?)")

        self.execute(qs, (node, cluster))

        r = self.fetchone()

        parent, path = props

        # The latest version.

             "from versions v "

             "where serial = %s "

             "and cluster != ?")

           Return the (serial, mtime) of the new version.

        """

             "values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")

        mtime = time()

        props = (node, hash, size, type, source, mtime, muser,

        if not all_props:

            q = q % ("serial", subq)

        else:

        self.execute(q, args + [cluster])

        props = self.fetchone()

            return props

        return None

        """Lookup the current versions of the given nodes.

           Return a list with their properties:

        """

        if not nodes:

        if not all_props:

            q = q % ("serial", subq, '')

        else:

        args += [cluster]

        self.execute(q, args)

        """Return a sequence of values for the properties of

           the version specified by serial and the keys, in the order given.

           If keys is empty, return all properties in the order

        """

             "from versions "

             "where serial = ?")

        self.execute(q, (serial,))

        return hash, size

    def attribute_get(self, serial, domain, keys=()):

           If keys is empty, return all attributes.

           Othwerise, return only those specified.

        """

                 "where key in (%s) and serial = ? and domain = ?" % (marks,))

            execute(q, keys + (serial, domain))

        else:

            execute(q, (serial, domain))

        return self.fetchall()

             "(serial, domain, node, is_latest, key, value) "

             "values (?, ?, ?, ?, ?, ?)")

        self.executemany(q, ((serial, domain, node, is_latest, k, v) for

    def attribute_del(self, serial, domain, keys=()):

        """Delete attributes of the version specified by serial.

        """

        if keys:

            self.executemany(q, ((serial, domain, key) for key in keys))

        else:

            q = "delete from attributes where serial = ? and domain = ?"

        args = []

        if included:

            subq += "(" + ' or '.join(('key = ?' for x in included)) + ")"

            subq += ")"

            args += [domain]

            append(subq)

        if excluded:

            subq += "(" + ' or '.join(('key = ?' for x in excluded)) + ")"

            subq += ")"

            args += [domain]

        if opers:

            for k, o, v in opers:

                subq += "key = ? and value %s ?" % (o,)

                subq += ")"

                args += [domain, k, v]

            args += [before]

        return q % where_cond, args

        """Return a list with all keys pairs defined

           for all latest versions under parent that

           do not belong to the cluster.

           Limit applies to the first list of tuples returned.

        """

        execute = self.execute

        if not all_props:

            q = q % ("v.serial", subq)

        else:

        args += [except_cluster, parent, start, nextling]

        start_index = len(args) - 2

            if props is None:

                break

            path = props[0]

            idx = path.find(delimiter, pfz)

            if idx < 0:

             "n.path in (%s)") % ','.join('?' for _ in paths)

        args = [domain]

        map(args.append, paths)

            q += "and v.cluster = ?"

            args += [cluster]

        rows = self.fetchall()

        group_by = itemgetter(slice(12))

        groups = groupby(rows, group_by)