Update Makefile

This reverts commit 1318f9e0c4.

Makefile

@@ -9,5 +9,5 @@ test:
 update-packages:
 	f=$$(mktemp) ;\
 	osc api /source/openSUSE:Factory?view=info | grep -v lsrcmd5 | grep srcmd5= | sed -e 's,.*package=",,; s,".*,,' | grep -v : > $$f ;\
-	echo _project >> $$f ;\
+	echo _project >> $$f;\
 	mv $$f packages

README.md

@@ -1,5 +1,18 @@
-sudo zypper in python3-psycopg2
+Installation
-sudo su - postgres
+------------
-# `createdb -O <LOCAL_USER> imported_git`
+
+    sudo zypper in python3-psycopg
+    sudo su - postgres
+    createdb -O <LOCAL_USER> imported_git`
 
 To reset the database, drop table scheme
+
+
+Gitea parameters
+----------------
+
+  * `GITEA_HOST` - default: src.opensuse.org
+  * `GITEA_USER` - Used to generate SSH links for push. Default: gitea
+  * `GITEA_ORG`  - target organization to push to
+  * `GITEA_DEFAULT_BRANCH` - default branch
+

git-importer.py

@@ -42,8 +42,8 @@ PROJECTS = [
 ]
 
 
-def export_package(package, repodir, cachedir, gc):
+def export_package(project, package, repodir, cachedir, gc):
-    exporter = GitExporter(URL_OBS, "openSUSE:Factory", package, repodir, cachedir)
+    exporter = GitExporter(URL_OBS, project, package, repodir, cachedir)
     exporter.set_gc_interval(gc)
     exporter.export_as_git()
 
@@ -51,6 +51,12 @@ def export_package(package, repodir, cachedir, gc):
 def main():
     parser = argparse.ArgumentParser(description="OBS history importer into git")
     parser.add_argument("packages", help="OBS package names", nargs="*")
+    parser.add_argument(
+        "-p",
+        "--project",
+        default="openSUSE:Factory",
+        help="Project to import/export, default is openSUSE:Factory",
+    )
     parser.add_argument(
         "-r",
         "--repodir",
@@ -110,10 +116,13 @@ def main():
     if not args.cachedir:
         args.cachedir = pathlib.Path("~/.cache/git-import/").expanduser()
 
-    importer = Importer(URL_OBS, "openSUSE:Factory", args.packages)
+    importer = Importer(URL_OBS, args.project, args.packages)
     importer.import_into_db()
     for package in args.packages:
-        export_package(package, args.repodir, args.cachedir, args.gc)
+        if not importer.package_with_scmsync(package):
+            export_package(args.project, package, args.repodir, args.cachedir, args.gc)
+        else:
+            logging.debug(f"{args.project}/{package} has scmsync links - skipping export")
 
 
 if __name__ == "__main__":

lib/config.py

@@ -14,8 +14,6 @@ def config(filename="database.ini", section="production"):
         for param in params:
             db[param[0]] = param[1]
     else:
-        raise Exception(
+        raise Exception(f"Section {section} not found in the {filename} file")
-            "Section {0} not found in the {1} file".format(section, filename)
-        )
 
     return db

lib/db.py

@@ -1,7 +1,6 @@
 import logging
 
-import psycopg2
+import psycopg
-from psycopg2.extras import LoggingConnection
 
 from lib.config import config
 
@@ -17,22 +16,20 @@ class DB:
             # read the connection parameters
             params = config(section=self.config_section)
             # connect to the PostgreSQL server
-            self.conn = psycopg2.connect(connection_factory=LoggingConnection, **params)
+            self.conn = psycopg.connect(conninfo=f"dbname={params['database']}")
-            logger = logging.getLogger(__name__)
+            logging.getLogger("psycopg.pool").setLevel(logging.INFO)
-            self.conn.initialize(logger)
 
-        except (Exception, psycopg2.DatabaseError) as error:
+        except (Exception, psycopg.DatabaseError) as error:
             print(error)
             raise error
 
     def schema_version(self):
         # create a cursor
         with self.conn.cursor() as cur:
-
             # execute a statement
             try:
                 cur.execute("SELECT MAX(version) from scheme")
-            except psycopg2.errors.UndefinedTable as error:
+            except psycopg.errors.UndefinedTable:
                 cur.close()
                 self.close()
                 self.connect()
@@ -146,9 +143,9 @@ class DB:
         )
         schemes[10] = (
             "ALTER TABLE revisions ADD COLUMN request_id INTEGER",
-            """ALTER TABLE revisions 
+            """ALTER TABLE revisions
                ADD CONSTRAINT request_id_foreign_key
-               FOREIGN KEY (request_id) 
+               FOREIGN KEY (request_id)
                REFERENCES requests (id)""",
             "UPDATE scheme SET version=10",
         )
@@ -273,7 +270,7 @@ class DB:
                         cur.execute(command)
             # commit the changes
             self.conn.commit()
-        except (Exception, psycopg2.DatabaseError) as error:
+        except (Exception, psycopg.DatabaseError) as error:
             print(error)
             self.close()
             raise error

lib/db_revision.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from hashlib import md5
 from pathlib import Path
-from typing import Optional
 
 from lib.db import DB
 from lib.obs_revision import OBSRevision
@@ -206,7 +205,7 @@ class DBRevision:
                 ):
                     continue
                 cur.execute(
-                    """INSERT INTO files (name, md5, size, mtime, revision_id) 
+                    """INSERT INTO files (name, md5, size, mtime, revision_id)
                             VALUES (%s,%s,%s,%s,%s)""",
                     (
                         entry.get("name"),
@@ -255,7 +254,7 @@ class DBRevision:
         self._files.sort(key=lambda x: x["name"])
         return self._files
 
-    def calc_delta(self, current_rev: Optional[DBRevision]):
+    def calc_delta(self, current_rev: DBRevision | None):
         """Calculate the list of files to download and to delete.
         Param current_rev is the revision that's currently checked out.
         If it's None, the repository is empty.

lib/git.py

@@ -28,61 +28,70 @@ class Git:
         self.path.mkdir(parents=True, exist_ok=True)
         self.open()
 
-    def open(self):
+    def git_run(self, args, **kwargs):
-        subprocess.run(
+        """Run a git command"""
-            ['git', 'init', '--object-format=sha256', '-b', 'factory'],
+        if "env" in kwargs:
+            envs = kwargs["env"].copy()
+            del kwargs["env"]
+        else:
+            envs = os.environ.copy()
+        envs["GIT_LFS_SKIP_SMUDGE"] = "1"
+        envs["GIT_CONFIG_GLOBAL"] = "/dev/null"
+        return subprocess.run(
+            ["git"] + args,
             cwd=self.path,
             check=True,
+            env=envs,
+            **kwargs,
         )
 
+    def open(self):
+        if not self.exists():
+            self.git_run(["init", "--object-format=sha256", "-b", "factory"])
+        self.git_run(["config", "lfs.allowincompletepush", "true"])
+
     def is_dirty(self):
         """Check if there is something to commit"""
-        status_str = subprocess.run(
+        status_str = self.git_run(
-            ['git', 'status', '--porcelain=2'],
+            ["status", "--porcelain=2"],
-            cwd=self.path,
             stdout=subprocess.PIPE,
-            check=True
+        ).stdout.decode("utf-8")
-        ).stdout.decode('utf-8')
+        return len(list(filter(None, status_str.split("\n")))) > 0
-        return len(list(filter(None, status_str.split('\n')))) > 0
 
     def branches(self):
-        br=subprocess.run(
+        br = (
-            ['git', 'for-each-ref', '--format=%(refname:short)', 'refs/heads/'],
+            self.git_run(
-            cwd=self.path,
+                ["for-each-ref", "--format=%(refname:short)", "refs/heads/"],
-            check=True,
+                stdout=subprocess.PIPE,
-            stdout=subprocess.PIPE
+            )
-        ).stdout.decode('utf-8').split()
+            .stdout.decode("utf-8")
+            .split()
+        )
         if len(br) == 0:
-            br.append('factory') # unborn branch?
+            br.append("factory")  # unborn branch?
         return br
 
-    def branch(self, branch, commit='HEAD'):
+    def branch(self, branch, commit="HEAD"):
-        commit = subprocess.run(
+        commit = (
-            ['git', 'rev-parse', '--verify', '--end-of-options', commit + '^{commit}'],
+            self.git_run(
-            cwd=self.path,
+                ["rev-parse", "--verify", "--end-of-options", commit + "^{commit}"],
-            check=True,
+                stdout=subprocess.PIPE,
-            stdout=subprocess.PIPE
+            )
-        ).stdout.decode('utf-8').strip()
+            .stdout.decode("utf-8")
-        return subprocess.run(['git', 'branch', branch, commit], check=True)
+            .strip()
+        )
+        return self.git_run(["branch", branch, commit])
 
     def checkout(self, branch):
         """Checkout into the branch HEAD"""
         new_branch = False
         if branch not in self.branches():
-            subprocess.run(
+            self.git_run(["switch", "-q", "--orphan", branch])
-                ['git', 'branch', '-q', branch, 'HEAD'],
-                cwd=self.path,
-                check=True
-            )
             new_branch = True
         else:
             ref = f"refs/heads/{branch}"
-            if (self.path/'.git'/ref).exists():
+            if (self.path / ".git" / ref).exists():
-                subprocess.run(
+                self.git_run(["switch", "--no-guess", "-q", branch])
-                    ['git', 'checkout', '-q', branch],
-                    cwd=self.path,
-                    check=True
-                )
         return new_branch
 
     def commit(
@@ -106,87 +115,79 @@ class Git:
             committer_time = committer_time if committer_time else user_time
 
         if self.is_dirty():
-            subprocess.run(
+            self.git_run(["add", "--all", "."])
-                ["git", "add", "--all", "."],
-                cwd=self.path,
-                check=True,
-            )
 
-        tree_id = subprocess.run(
+        tree_id = (
-            ['git', 'write-tree'],
+            self.git_run(["write-tree"], stdout=subprocess.PIPE)
-            cwd=self.path,
+            .stdout.decode("utf-8")
-            check=True,
+            .strip()
-            stdout=subprocess.PIPE
+        )
-        ).stdout.decode('utf-8').strip()
 
         parent_array = []
         if isinstance(parents, list):
             for parent in filter(None, parents):
-                parent_array = parent_array + ['-p', parent]
+                parent_array = parent_array + ["-p", parent]
         elif isinstance(parents, str):
-            parents_array = ['-p', parents]
+            parent_array = ["-p", parents]
 
-        commit_id = subprocess.run(
+        commit_id = (
-            ['git', 'commit-tree'] + parent_array + [tree_id],
+            self.git_run(
-            cwd=self.path,
+                ["commit-tree"] + parent_array + [tree_id],
-            env={
+                env={
-                "GIT_AUTHOR_NAME": user,
+                    "GIT_AUTHOR_NAME": user,
-                "GIT_AUTHOR_EMAIL": user_email,
+                    "GIT_AUTHOR_EMAIL": user_email,
-                "GIT_AUTHOR_DATE": f"{int(user_time.timestamp())} +0000",
+                    "GIT_AUTHOR_DATE": f"{int(user_time.timestamp())} +0000",
-                "GIT_COMMITTER_NAME": committer,
+                    "GIT_COMMITTER_NAME": committer,
-                "GIT_COMMITTER_EMAIL": committer_email,
+                    "GIT_COMMITTER_EMAIL": committer_email,
-                "GIT_COMMITTER_DATE": f"{int(committer_time.timestamp())} +0000",
+                    "GIT_COMMITTER_DATE": f"{int(committer_time.timestamp())} +0000",
-            },
+                },
-            input=message.encode('utf-8'),
+                input=message.encode("utf-8"),
-            check=True,
+                stdout=subprocess.PIPE,
-            stdout=subprocess.PIPE
+            )
-        ).stdout.decode('utf-8').rstrip()
+            .stdout.decode("utf-8")
-        subprocess.run(
+            .rstrip()
-            ['git', 'reset', '--soft', commit_id],
-            cwd=self.path,
-            check=True,
         )
+        self.git_run(["reset", "--soft", commit_id])
         return commit_id
 
-    def branch_head(self, branch='HEAD'):
+    def branch_head(self, branch="HEAD"):
-        return subprocess.run(
+        return (
-            ['git', 'rev-parse', '--verify', '--end-of-options', branch],
+            self.git_run(
-            cwd=self.path,
+                ["rev-parse", "--verify", "--end-of-options", branch],
-            check=True,
+                stdout=subprocess.PIPE,
-            stdout=subprocess.PIPE
+            )
-        ).stdout.decode('utf-8').strip()
+            .stdout.decode("utf-8")
+            .strip()
+        )
 
     def set_branch_head(self, branch, commit):
-        return subprocess.run(
+        return self.git_run(["update-ref", f"refs/heads/{branch}", commit])
-            ['git', 'branch', '-f', branch, commit],
-            cwd=self.path,
-            check=True,
-        )
 
     def gc(self):
         logging.debug(f"Garbage recollect and repackage {self.path}")
-        subprocess.run(
+        self.git_run(
-            ["git", "gc", "--auto"],
+            ["gc", "--auto"],
-            cwd=self.path,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
         )
 
-#    def clean(self):
+    #    def clean(self):
-#        for path, _ in self.repo.status().items():
+    #        for path, _ in self.repo.status().items():
-#            logging.debug(f"Cleaning {path}")
+    #            logging.debug(f"Cleaning {path}")
-#            try:
+    #            try:
-#                (self.path / path).unlink()
+    #                (self.path / path).unlink()
-#                self.repo.index.remove(path)
+    #                self.repo.index.remove(path)
-#            except Exception as e:
+    #            except Exception as e:
-#                logging.warning(f"Error removing file {path}: {e}")
+    #                logging.warning(f"Error removing file {path}: {e}")
 
     def add(self, filename):
-        subprocess.run(
+        self.git_run(["add", ":(literal)" + str(filename)])
-            ['git', 'add', filename],
+
-            cwd=self.path,
+    def add_default_gitignore(self):
-            check=True,
+        if not (self.path / ".gitignore").exists():
-        )
+            with (self.path / ".gitignore").open("w") as f:
+                f.write(".osc\n")
+            self.add(".gitignore")
 
     def add_default_lfs_gitattributes(self, force=False):
         if not (self.path / ".gitattributes").exists() or force:
@@ -240,10 +241,8 @@ class Git:
             return any(fnmatch.fnmatch(filename, line) for line in patterns)
 
     def remove(self, file: pathlib.Path):
-        subprocess.run(
+        self.git_run(
-            ['git', 'rm', '-q', '--ignore-unmatch', file.name],
+            ["rm", "-q", "-f", "--ignore-unmatch", ":(literal)" + file.name],
-            cwd=self.path,
-            check=True,
         )
         patterns = self.get_specific_lfs_gitattributes()
         if file.name in patterns:
@@ -253,15 +252,27 @@ class Git:
     def add_gitea_remote(self, package):
         repo_name = package.replace("+", "_")
         org_name = "rpm"
+        gitea_user = "gitea"
+        gitea_host = "src.opensuse.org"
+        default_branch = "factory"
+
+        if os.getenv("GITEA_HOST"):
+            gitea_host = getenv("GITEA_HOST")
+        if os.getenv("GITEA_USER"):
+            gitea_user = getenv("GITEA_USER")
+        if os.getenv("GITEA_ORG"):
+            org_name = getenv("GITEA_ORG")
+        if os.getenv("GITEA_DEFAULT_BRANCH"):
+            default_branch = getenv("GITEA_DEFAULT_BRANCH")
 
         if not os.getenv("GITEA_TOKEN"):
             logging.warning("Not adding a remote due to missing $GITEA_TOKEN")
             return
 
-        url = f"https://src.opensuse.org/api/v1/org/{org_name}/repos"
+        url = f"https://{gitea_host}/api/v1/org/{org_name}/repos"
         response = requests.post(
             url,
-            data={"name": repo_name},
+            data={"name": repo_name, "object_format_name": "sha256", "default_branch": default_branch},
             headers={"Authorization": f"token {os.getenv('GITEA_TOKEN')}"},
             timeout=10,
         )
@@ -269,23 +280,21 @@ class Git:
         # 201 Created
         if response.status_code not in (201, 409):
             print(response.data)
-        url = f"gitea@src.opensuse.org:{org_name}/{repo_name}.git"
+        url = f"{gitea_user}@{gitea_host}:{org_name}/{repo_name}.git"
-        subprocess.run(
+        self.git_run(
-            ['git', 'remote', 'add', 'origin', url],
+            ["remote", "add", "origin", url],
-            cwd=self.path,
-            check=True,
         )
 
     def push(self, force=False):
-        cmd = ['git', 'push'];
+        if "origin" not in self.git_run(
-        if force:
+            ["remote"],
-            cmd.append('-f')
+            stdout=subprocess.PIPE,
-        cmd.append('origin')
+        ).stdout.decode("utf-8"):
-        cmd.append('refs/heads/factory');
+            logging.warning("Not pushing to remote because no 'origin' configured")
-        cmd.append('refs/heads/devel');
+            return
-        subprocess.run(
-            cmd,
-            cwd=self.path,
-            check=True,
-        )
 
+        cmd = ["push"]
+        if force:
+            cmd.append("-f")
+        cmd += ["origin", "--all"]
+        self.git_run(cmd)

lib/git_exporter.py

@@ -29,7 +29,7 @@ class GitExporter:
             self.git.open()
         else:
             self.git.create()
-            self.git.add_gitea_remote(package)
+            # self.git.add_gitea_remote(package)
         self.state_file = os.path.join(self.git.path, ".git", "_flat_state.yaml")
         self.gc_interval = 200
         self.cachedir = cachedir
@@ -40,9 +40,9 @@ class GitExporter:
     def check_repo_state(self, flats, branch_state):
         state_data = dict()
         if os.path.exists(self.state_file):
-            with open(self.state_file, "r") as f:
+            with open(self.state_file) as f:
                 state_data = yaml.safe_load(f)
-                if type(state_data) != dict:
+                if not isinstance(state_data, dict):
                     state_data = {}
         left_to_commit = []
         for flat in reversed(flats):
@@ -86,6 +86,11 @@ class GitExporter:
             logging.debug(f"Committing {flat}")
             self.commit_flat(flat, branch_state)
 
+        # make sure that we create devel branch
+        if not branch_state["devel"]:
+            logging.debug("force creating devel")
+            self.git.set_branch_head("devel", self.git.branch_head("factory"))
+
         self.git.push(force=True)
 
     def run_gc(self):
@@ -150,6 +155,7 @@ class GitExporter:
 
         # create file if not existant
         self.git.add_default_lfs_gitattributes(force=False)
+        self.git.add_default_gitignore()
 
         to_download, to_delete = flat.commit.calc_delta(branch_state[flat.branch])
         for file in to_delete:

lib/importer.py

@@ -26,13 +26,16 @@ class Importer:
         # Import multiple Factory packages into the database
         self.packages = packages
         self.project = project
+        self.scmsync_cache = dict()
+        self.packages_with_scmsync = set()
 
         self.db = DB()
         self.obs = OBS(api_url)
-        assert project == "openSUSE:Factory"
+        assert not self.has_scmsync(project)
         self.refreshed_packages = set()
         self.gone_packages_set = None
 
+
     def import_request(self, number):
         self.obs.request(number).import_into_db(self.db)
 
@@ -167,7 +170,7 @@ class Importer:
         with self.db.cursor() as cur:
             cur.execute(
                 "SELECT * FROM revisions WHERE package=%s AND broken=FALSE AND expanded_srcmd5 IS NULL",
-                (package, )
+                (package,),
             )
             return [DBRevision(self.db, row) for row in cur.fetchall()]
 
@@ -213,6 +216,10 @@ class Importer:
             return
         logging.debug(f"Refresh {project}/{package}")
         self.refreshed_packages.add(key)
+        if self.has_scmsync(project) or self.has_scmsync(key):
+            self.packages_with_scmsync.add(package)
+            logging.debug(f"{project}/{package} already in Git - skipping")
+            return
         self.update_db_package(project, package)
         self.fetch_all_linked_packages(project, package)
 
@@ -255,3 +262,18 @@ class Importer:
                 for line in f.readlines():
                     self.gone_packages_set.add(line.strip())
         return key in self.gone_packages_set
+
+    def has_scmsync(self, key):
+        if key in self.scmsync_cache:
+            return self.scmsync_cache[key]
+
+        root = self.obs._meta(key)
+        scmsync_exists = False
+        if root is not None:
+            scmsync_exists = root.find('scmsync') is not None
+        self.scmsync_cache[key] = scmsync_exists
+        return scmsync_exists
+
+    def package_with_scmsync(self, package):
+        return package in self.packages_with_scmsync
+

lib/lfs_oid.py

@@ -83,6 +83,7 @@ class LFSOid:
             self.register()
 
     def check(self):
+        return True
         url = f"http://localhost:9999/check/{self.sha256}/{self.size}"
         response = requests.get(
             url,

lib/obs.py

@@ -73,11 +73,11 @@ class OBS:
         logging.debug(f"GET {url}")
         return ET.parse(osc.core.http_GET(url)).getroot()
 
-    def _meta(self, project, package, **params):
+    def _meta(self, key, **params):
         try:
-            root = self._xml(f"source/{project}/{package}/_meta", **params)
+            root = self._xml(f"source/{key}/_meta", **params)
         except HTTPError:
-            logging.error(f"Package [{project}/{package} {params}] has no meta")
+            logging.error(f"Project/Package [{key} {params}] has no meta")
             return None
         return root
 
@@ -118,13 +118,13 @@ class OBS:
         return root
 
     def exists(self, project, package):
-        root = self._meta(project, package)
+        root = self._meta(f"{project}/{package}")
         if root is None:
             return False
         return root.get("project") == project
 
     def devel_project(self, project, package):
-        root = self._meta(project, package)
+        root = self._meta(f"{project}/{package}")
         devel = root.find("devel")
         if devel is None:
             return None
@@ -148,28 +148,12 @@ class OBS:
         ]
 
     def _download(self, project, package, name, revision):
-        # the object might be deleted but we can only pass deleted=1
-        # if it is actually deleted
-        deleted = 0
-        while deleted < 2:
-            url = osc.core.makeurl(
-                self.url,
-                ["source", project, package, urllib.parse.quote(name)],
-                {"rev": revision, "expand": 1, "deleted": deleted if deleted else ()},
-            )
-            try:
-                osc.core.http_request("HEAD", url)
-                break
-            except Exception:
-                pass
-            deleted += 1
-
         url = osc.core.makeurl(
-                self.url,
+            self.url,
-                ["source", project, package, urllib.parse.quote(name)],
+            ["source", project, package, name],
-                {"rev": revision, "expand": 1, "deleted": 1 if deleted else ()},
+            {"rev": revision, "expand": 1},
-            )
+        )
-        return osc.core.http_request("GET", url)
+        return osc.core.http_GET(url)
 
     def download(
         self,
@@ -181,7 +165,6 @@ class OBS:
         cachedir: str,
         file_md5: str,
     ) -> None:
-
         cached_file = self._path_from_md5(name, cachedir, file_md5)
         if not self.in_cache(name, cachedir, file_md5):
             with (dirpath / name).open("wb") as f:

lib/proxy_sha256.py

@@ -41,7 +41,6 @@ class ProxySHA256:
             }
 
     def put(self, project, package, name, revision, file_md5, size):
-
         if not self.mime:
             self.mime = magic.Magic(mime=True)
 

lib/tree_builder.py

@@ -1,4 +1,3 @@
-from typing import Dict
 from xmlrpc.client import Boolean
 
 from lib.db_revision import DBRevision
@@ -138,7 +137,7 @@ class TreeBuilder:
                 self.requests.add(node.revision.request_id)
 
         class FindMergeWalker(AbstractWalker):
-            def __init__(self, builder: TreeBuilder, requests: Dict) -> None:
+            def __init__(self, builder: TreeBuilder, requests: dict) -> None:
                 super().__init__()
                 self.source_revisions = dict()
                 self.builder = builder

opensuse-monitor.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python3
+import json
+from pathlib import Path
+import pika
+import random
+import time
+
+MY_TASKS_DIR = Path(__file__).parent / "tasks"
+
+
+def listen_events():
+    connection = pika.BlockingConnection(
+        pika.URLParameters("amqps://opensuse:opensuse@rabbit.opensuse.org")
+    )
+    channel = connection.channel()
+
+    channel.exchange_declare(
+        exchange="pubsub", exchange_type="topic", passive=True, durable=False
+    )
+
+    result = channel.queue_declare("", exclusive=True)
+    queue_name = result.method.queue
+
+    channel.queue_bind(
+        exchange="pubsub", queue=queue_name, routing_key="opensuse.obs.package.commit"
+    )
+
+    print(" [*] Waiting for logs. To exit press CTRL+C")
+
+    def callback(ch, method, properties, body):
+        if method.routing_key not in ("opensuse.obs.package.commit",):
+            return
+        body = json.loads(body)
+        if (
+            "project" in body
+            and "package" in body
+            and body["project"] == "openSUSE:Factory"
+        ):
+            if "/" in body["package"]:
+                return
+
+            (MY_TASKS_DIR / body["package"]).touch()
+            print(" [x] %r:%r" % (method.routing_key, body["package"]))
+
+    channel.basic_consume(queue_name, callback, auto_ack=True)
+
+    channel.start_consuming()
+
+
+def main():
+    while True:
+        try:
+            listen_events()
+        except (pika.exceptions.ConnectionClosed, pika.exceptions.AMQPHeartbeatTimeout):
+            time.sleep(random.randint(10, 100))
+
+
+if __name__ == "__main__":
+    main()

tasks/.gitignore

@@ -0,0 +1 @@
+*

update-tasks.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+#
+cd /space/dmueller/git-importer
+
+source credentials.sh
+
+while true; do
+   for i in $PWD/tasks/*; do
+       if test -f "$i"; then
+            echo "$(date): Importing $(basename $i)"
+            if ! python3 ./git-importer.py -c repos/.cache $(basename $i); then
+                mkdir -p $PWD/failed-tasks
+                mv -f $i $PWD/failed-tasks
+            fi
+            rm -f $i
+        fi
+   done
+   inotifywait -q -e create $PWD/tasks
+done