git-importer/lib/db_revision.py

class DBRevision:
    def __init__(self, row):
        # need to stay in sync with the schema creation in db.py
        (
            self.dbid,
            self.project,
            self.package,
            self.rev,
            self.unexpanded_srcmd5,
            self.commit_time,
            self.userid,
            self.comment,
            self.broken,
            self.expanded_srcmd5,
            self.request_number,
            self.request_id,
        ) = row

    def __str__(self):
        return f"Rev {self.project}/{self.rev} Md5 {self.unexpanded_srcmd5} {self.commit_time} {self.userid} {self.request_number}"

    def __repr__(self):
        return f"[{self.__str__()}]"

    def links_to(self, db, project, package):
        db.cursor().execute(
            "INSERT INTO links (revision_id, project, package) VALUES (%s,%s,%s)",
            (self.dbid, project, package),
        )

    @classmethod
    def import_obs_rev(cls, db, revision):
        cur = db.cursor()
        cur.execute(
            """INSERT INTO revisions (project, package, rev, unexpanded_srcmd5, commit_time, userid, comment, request_number)  
                    VALUES(%s, %s, %s, %s, %s, %s, %s, %s)""",
            (
                revision.project,
                revision.package,
                revision.rev,
                revision.unexpanded_srcmd5,
                revision.time,
                revision.userid,
                revision.comment,
                revision.request_number,
            ),
        )
        cur.close()
        return cls.fetch_revision(db, revision.project, revision.package, revision.rev)

    @classmethod
    def fetch_revision(cls, db, project, package, rev):
        cur = db.cursor()
        cur.execute(
            "SELECT * FROM revisions where project=%s and package=%s and rev=%s",
            (project, package, str(rev)),
        )
        row = cur.fetchone()
        cur.close()
        return DBRevision(row)

    @classmethod
    def latest_revision(cls, db, project, package):
        cur = db.cursor()
        cur.execute(
            "SELECT MAX(rev) FROM revisions where project=%s and package=%s",
            (project, package),
        )
        max = cur.fetchone()[0]
        cur.close()
        if max:
            return DBRevision.fetch_revision(db, project, package, int(max))
        return None

    @classmethod
    def all_revisions(cls, db, project, package):
        cur = db.cursor()
        cur.execute(
            "SELECT * FROM revisions where project=%s and package=%s",
            (project, package),
        )
        ret = []
        for row in cur.fetchall():
            ret.append(DBRevision(row))
        cur.close()
        return ret

    def linked_rev(self, db):
        cur = db.cursor()
        cur.execute(
            "SELECT project,package FROM links where revision_id=%s", (self.dbid,)
        )
        row = cur.fetchone()
        if not row:
            cur.close()
            return None
        project, package = row
        cur.execute(
            "SELECT * FROM revisions where project=%s and package=%s and commit_time <= %s ORDER BY commit_time DESC LIMIT 1",
            (project, package, self.commit_time),
        )
        revisions = [DBRevision(row) for row in cur.fetchall()]
        cur.close()
        if revisions:
            return revisions[0]
        return None

    def set_broken(self, db):
        cur = db.cursor()
        cur.execute("UPDATE revisions SET broken=TRUE where id=%s", (self.dbid,))
        cur.close()

    def import_dir_list(self, db, xml):
        cur = db.cursor()
        cur.execute(
            "UPDATE revisions SET expanded_srcmd5=%s where id=%s",
            (xml.get("srcmd5"), self.dbid),
        )
        for entry in xml.findall("entry"):
            cur.execute(
                """INSERT INTO files (name, md5, size, mtime, revision_id) 
                           VALUES (%s,%s,%s,%s,%s)""",
                (
                    entry.get("name"),
                    entry.get("md5"),
                    entry.get("size"),
                    entry.get("mtime"),
                    self.dbid,
                ),
            )
        cur.close()

    @classmethod
    def requests_to_fetch(self, db, project, package):
        cur = db.cursor()
        cur.execute(
            """SELECT request_number FROM revisions revs left join requests
            reqs on reqs.number=revs.request_number where reqs.id is null and
            revs.request_number is not null and project=%s and package=%s;""",
            (project, package),
        )
        ret = [row[0] for row in cur.fetchall()]
        cur.close()
        return ret