utils: add maintainer-update to utils

- Add a test case specifically verifying that `Gitea.SetLabels`
  is called with `staging/Auto` when a *new* project PR is created
  for submodules.
- Verify `PrjGitDescription` and `SetSubmodulesToMatchPRSet` behave
  correctly when a single `PRSet` contains 5+ different package
  repositories.

.gitea/workflows/go-generate-check.yaml

@@ -0,0 +1,33 @@
+name: go-generate-check
+on:
+  push:
+    branches: ['main']
+    paths:
+      - '**.go'
+      - '**.mod'
+      - '**.sum'
+  pull_request:
+    paths:
+      - '**.go'
+      - '**.mod'
+      - '**.sum'
+  workflow_dispatch:
+jobs:
+  go-generate-check:
+    name: go-generate-check
+    container:
+      image: registry.opensuse.org/devel/factory/git-workflow/containers/opensuse/bci/golang-extended:latest
+    steps:
+      - run: git clone --no-checkout --depth 1 ${{ gitea.server_url }}/${{ gitea.repository }} .
+      - run: git fetch origin ${{ gitea.ref }}
+      - run: git checkout FETCH_HEAD
+      - run: go generate -C common
+      - run: go generate -C workflow-pr
+      - run: git add -N .; git diff
+      - run: |
+          status=$(git status --short)
+          if [[ -n "$status" ]]; then
+            echo -e "$status"
+            echo "Please commit the differences from running: go generate"
+            false
+          fi

.gitea/workflows/go-generate-push.yaml

@@ -0,0 +1,24 @@
+name: go-generate-push
+on:
+  workflow_dispatch:
+jobs:
+  go-generate-push:
+    name: go-generate-push
+    container:
+      image: registry.opensuse.org/devel/factory/git-workflow/containers/opensuse/bci/golang-extended:latest
+    steps:
+      - run: git clone --no-checkout --depth 1 ${{ gitea.server_url }}/${{ gitea.repository }} .
+      - run: git fetch origin ${{ gitea.ref }}
+      - run: git checkout FETCH_HEAD
+      - run: go generate -C common
+      - run: go generate -C workflow-pr
+      - run: |
+          host=${{ gitea.server_url }}
+          host=${host#https://}
+          echo $host
+          git remote set-url origin "https://x-access-token:${{ secrets.GITEA_TOKEN }}@$host/${{ gitea.repository }}"
+          git config user.name "Gitea Actions"
+          git config user.email "gitea_noreply@opensuse.org"
+      - run: 'git status --short; git status --porcelain=2|grep --quiet -v . || ( git add .;git commit -m "CI run result of: go generate"; git push origin HEAD:${{ gitea.ref }} )'
+      - run: git log -p FETCH_HEAD...HEAD
+      - run: git log --numstat FETCH_HEAD...HEAD

.gitea/workflows/go-vendor-check.yaml

@@ -0,0 +1,33 @@
+name: go-vendor-check
+on:
+  push:
+    branches: ['main']
+    paths:
+      - '**.mod'
+      - '**.sum'
+  pull_request:
+    paths:
+      - '**.mod'
+      - '**.sum'
+  workflow_dispatch:
+jobs:
+  go-generate-check:
+    name: go-vendor-check
+    container:
+      image: registry.opensuse.org/devel/factory/git-workflow/containers/opensuse/bci/golang-extended:latest
+    steps:
+      - run: git clone --no-checkout --depth 1 ${{ gitea.server_url }}/${{ gitea.repository }} .
+      - run: git fetch origin ${{ gitea.ref }}
+      - run: git checkout FETCH_HEAD
+      - run: go mod download
+      - run: go mod vendor
+      - run: go mod verify
+      - run: git add -N .; git diff
+      - run: go mod tidy -diff || true
+      - run: |
+          status=$(git status --short)
+          if [[ -n "$status" ]]; then
+            echo -e "$status"
+            echo "Please commit the differences from running: go generate"
+            false
+          fi

.gitea/workflows/go-vendor-push.yaml

@@ -0,0 +1,26 @@
+name: go-generate-push
+on:
+  workflow_dispatch:
+jobs:
+  go-generate-push:
+    name: go-generate-push
+    container:
+      image: registry.opensuse.org/devel/factory/git-workflow/containers/opensuse/bci/golang-extended:latest
+    steps:
+      - run: git clone --no-checkout --depth 1 ${{ gitea.server_url }}/${{ gitea.repository }} .
+      - run: git fetch origin ${{ gitea.ref }}
+      - run: git checkout FETCH_HEAD
+      - run: go mod download
+      - run: go mod vendor
+      - run: go mod verify
+      - run: |
+          host=${{ gitea.server_url }}
+          host=${host#https://}
+          echo $host
+          git remote set-url origin "https://x-access-token:${{ secrets.GITEA_TOKEN }}@$host/${{ gitea.repository }}"
+          git config user.name "Gitea Actions"
+          git config user.email "gitea_noreply@opensuse.org"
+      - run: 'git status --short; git status --porcelain=2|grep --quiet -v . || ( git add .;git commit -m "CI run result of: go mod vendor"; git push origin HEAD:${{ gitea.ref }} )'
+      - run: go mod tidy -diff || true
+      - run: git log -p FETCH_HEAD...HEAD
+      - run: git log --numstat FETCH_HEAD...HEAD

.gitignore

@@ -1,5 +1,2 @@
-mock
-node_modules
-*.obscpio
-autogits-tmp.tar.zst
 *.osc
+*.conf

README.md

@@ -5,11 +5,15 @@ The bots that drive Git Workflow for package management
 
   * devel-importer     -- helper to import an OBS devel project into a Gitea organization
   * gitea-events-rabbitmq-publisher -- takes all events from a Gitea organization (webhook) and publishes it on a RabbitMQ instance
+  * gitea-status-proxy -- allows bots without code owner permission to set Gitea's commit status
+  * group-review       -- group review proxy
+  * hujson             -- translates JWCC (json with commas and comments) to Standard JSON
+  * obs-forward-bot    -- forwards PR as OBS sr (TODO)
   * obs-staging-bot    -- build bot for a PR
   * obs-status-service -- report build status of an OBS project as an SVG
   * workflow-pr        -- keeps PR to _ObsPrj consistent with a PR to a package update
   * workflow-direct    -- update _ObsPrj based on direct pushes and repo creations/removals from organization
-  * staging-utils      -- review tooling for PR
+  * staging-utils      -- review tooling for PR (TODO)
     - list PR
     - merge PR
     - split PR
@@ -19,7 +23,18 @@ The bots that drive Git Workflow for package management
 Bugs
 ----
 
-Report bugs to issue tracker at https://src.opensuse.org/adamm/autogits
+Report bugs to issue tracker at https://src.opensuse.org/git-workflow/autogits
 
 
+Build Status
+------------
+
+Devel project build status (`main` branch):
+
+![devel:Factory:git-workflow](https://br.opensuse.org/status/devel:Factory:git-workflow/autogits)
+
+`staging` branch build status:
+
+![Staging Build Status](https://br.opensuse.org/status/home:adamm:autogits/autogits)
+
 

_service

@@ -1,15 +0,0 @@
-<services>
- <!-- workaround, go_modules needs a tar and obs_scm doesn't take file://. -->
- <service name="roast" mode="manual">
-   <param name="target">.</param>
-   <param name="reproducible">true</param>
-   <param name="outfile">autogits-tmp.tar.zst</param>
-   <param name="exclude">autogits-tmp.tar.zst</param>
- </service>
- <service name="go_modules" mode="manual">
-   <param name="basename">./</param>
-   <param name="compression">zst</param>
-   <param name="vendorname">vendor</param>
- </service>
-</services>
-

autogits.spec

@@ -17,15 +17,14 @@
 
 
 Name:           autogits
-Version:        0
+Version:        1
 Release:        0
 Summary:        GitWorkflow utilities
 License:        GPL-2.0-or-later
 URL:            https://src.opensuse.org/adamm/autogits
-Source1:        vendor.tar.zst
-BuildRequires:  golang-packaging
+BuildRequires:  git
 BuildRequires:  systemd-rpm-macros
-BuildRequires:  zstd
+BuildRequires:  go
 %{?systemd_ordering}
 
 %description
@@ -33,160 +32,273 @@ Git Workflow tooling and utilities enabling automated handing of OBS projects
 as git repositories
 
 
-%package -n gitea-events-rabbitmq-publisher
+%package devel-importer
+Summary:        Imports devel projects from obs to git
+
+%description -n autogits-devel-importer
+Command-line tool to import devel projects from obs to git
+
+
+%package doc
+Summary:        Common documentation files
+BuildArch:      noarch
+
+%description -n autogits-doc
+Common documentation files
+
+
+%package gitea-events-rabbitmq-publisher
 Summary:        Publishes Gitea webhook data via RabbitMQ
 
-%description -n gitea-events-rabbitmq-publisher
+%description gitea-events-rabbitmq-publisher
 Listens on an HTTP socket and publishes Gitea events on a RabbitMQ instance
 with a topic
   <scope>.src.$organization.$webhook_type.[$webhook_action_type]
 
 
-%package -n doc
-Summary:        Common documentation files
+%package gitea-status-proxy
+Summary:        Proxy for setting commit status in Gitea
 
-%description -n doc
-Common documentation files
+%description gitea-status-proxy
+Setting commit status requires code write access token. This proxy
+is middleware that delegates status setting without access to other APIs
 
-
-%package -n devel-importer
-Summary:        Imports devel projects from obs to git
-
-%description -n devel-importer
-Command-line tool to import devel projects from obs to git
-
-
-%package -n group-review
+%package group-review
 Summary:        Reviews of groups defined in ProjectGit
 
-%description -n group-review
+%description group-review
 Is used to handle reviews associated with groups defined in the
 ProjectGit.
 
 
-%package -n obs-staging-bot
+%package obs-forward-bot
+Summary:        obs-forward-bot
+
+%description obs-forward-bot
+
+
+%package obs-staging-bot
 Summary:        Build a PR against a ProjectGit, if review is requested
 
-%description -n obs-staging-bot
+%description obs-staging-bot
 Build a PR against a ProjectGit, if review is requested.
 
 
-%package -n obs-status-service
+%package obs-status-service
 Summary:        Reports build status of OBS service as an easily to produce SVG
 
-%description -n obs-status-service
+%description obs-status-service
 Reports build status of OBS service as an easily to produce SVG
 
 
-%package -n workflow-direct
-Summary:        Keep ProjectGit in sync for a devel project
+%package utils
+Summary:        HuJSON to JSON parser
+Provides:       hujson
+Provides:       /usr/bin/hujson
 
-%description -n workflow-direct
+%description utils
+HuJSON to JSON parser, using stdin -> stdout pipe
+
+
+%package workflow-direct
+Summary:        Keep ProjectGit in sync for a devel project
+Requires:       openssh-clients
+Requires:       git-core
+
+%description workflow-direct
 Keep ProjectGit in sync with packages in the organization of a devel project
 
 
-%package -n workflow-pr
+%package workflow-pr
 Summary:        Keeps ProjectGit PR in-sync with a PackageGit PR
+Requires:       openssh-clients
+Requires:       git-core
 
-%description -n workflow-pr
+%description workflow-pr
 Keeps ProjectGit PR in-sync with a PackageGit PR
 
 
 
 %prep
 cp -r /home/abuild/rpmbuild/SOURCES/* ./
-tar x --zstd -f %{SOURCE1}
 
 %build
 go build \
-   -C gitea-events-rabbitmq-publisher \
-   -mod=vendor \
+   -C devel-importer \
    -buildmode=pie
 go build \
-   -C devel-importer \
-   -mod=vendor \
+   -C utils/hujson \
+   -buildmode=pie
+go build \
+   -C utils/maintainer-update \
+   -buildmode=pie
+go build \
+   -C gitea-events-rabbitmq-publisher \
+   -buildmode=pie
+go build \
+   -C gitea_status_proxy \
    -buildmode=pie
 go build \
    -C group-review \
-   -mod=vendor \
+   -buildmode=pie
+go build \
+   -C obs-forward-bot \
    -buildmode=pie
 go build \
    -C obs-staging-bot \
-   -mod=vendor \
    -buildmode=pie
 go build \
    -C obs-status-service \
-   -mod=vendor \
    -buildmode=pie
-#go build \
-#   -C workflow-direct \
-#   -mod=vendor \
-#   -buildmode=pie
-#go build \
-#   -C workflow-pr \
-#   -mod=vendor \
-#   -buildmode=pie
+go build \
+   -C workflow-direct \
+   -buildmode=pie
+go build \
+   -C workflow-pr \
+   -buildmode=pie
+
+%check
+go test -C common -v
+go test -C group-review -v
+go test -C obs-staging-bot -v
+go test -C obs-status-service -v
+go test -C workflow-direct -v
+# TODO build fails
+#go test -C workflow-pr -v
 
 %install
+install -D -m0755 devel-importer/devel-importer                                    %{buildroot}%{_bindir}/devel-importer
 install -D -m0755 gitea-events-rabbitmq-publisher/gitea-events-rabbitmq-publisher  %{buildroot}%{_bindir}/gitea-events-rabbitmq-publisher
 install -D -m0644 systemd/gitea-events-rabbitmq-publisher.service                  %{buildroot}%{_unitdir}/gitea-events-rabbitmq-publisher.service
-install -D -m0755 devel-importer/devel-importer                                    %{buildroot}%{_bindir}/devel-importer
+install -D -m0755 gitea_status_proxy/gitea_status_proxy                            %{buildroot}%{_bindir}/gitea_status_proxy
 install -D -m0755 group-review/group-review                                        %{buildroot}%{_bindir}/group-review
+install -D -m0644 systemd/group-review@.service                                    %{buildroot}%{_unitdir}/group-review@.service
+install -D -m0755 obs-forward-bot/obs-forward-bot                                  %{buildroot}%{_bindir}/obs-forward-bot
 install -D -m0755 obs-staging-bot/obs-staging-bot                                  %{buildroot}%{_bindir}/obs-staging-bot
+install -D -m0644 systemd/obs-staging-bot.service                                  %{buildroot}%{_unitdir}/obs-staging-bot.service
 install -D -m0755 obs-status-service/obs-status-service                            %{buildroot}%{_bindir}/obs-status-service
-#install -D -m0755 workflow-direct/workflow-direct                                  %{buildroot}%{_bindir}/workflow-direct
-#install -D -m0755 workflow-pr/workflow-pr                                          %{buildroot}%{_bindir}/workflow-pr
+install -D -m0644 systemd/obs-status-service.service                               %{buildroot}%{_unitdir}/obs-status-service.service
+install -D -m0755 workflow-direct/workflow-direct                                  %{buildroot}%{_bindir}/workflow-direct
+install -D -m0644 systemd/workflow-direct@.service                                 %{buildroot}%{_unitdir}/workflow-direct@.service
+install -D -m0755 workflow-pr/workflow-pr                                          %{buildroot}%{_bindir}/workflow-pr
+install -D -m0755 utils/hujson/hujson                                              %{buildroot}%{_bindir}/hujson
+install -D -m0755 utils/maintainer-update/maintainer-update                        %{buildroot}${_bindir}/maintainer-update
 
-%pre -n gitea-events-rabbitmq-publisher
+%pre gitea-events-rabbitmq-publisher
 %service_add_pre gitea-events-rabbitmq-publisher.service
 
-%post -n gitea-events-rabbitmq-publisher
+%post gitea-events-rabbitmq-publisher
 %service_add_post gitea-events-rabbitmq-publisher.service
 
-%preun -n gitea-events-rabbitmq-publisher
+%preun gitea-events-rabbitmq-publisher
 %service_del_preun gitea-events-rabbitmq-publisher.service
 
-%postun -n gitea-events-rabbitmq-publisher
+%postun gitea-events-rabbitmq-publisher
 %service_del_postun gitea-events-rabbitmq-publisher.service
 
-%files -n gitea-events-rabbitmq-publisher
+%pre group-review
+%service_add_pre group-review@.service
+
+%post group-review
+%service_add_post group-review@.service
+
+%preun group-review
+%service_del_preun group-review@.service
+
+%postun group-review
+%service_del_postun group-review@.service
+
+%pre obs-staging-bot
+%service_add_pre obs-staging-bot.service
+
+%post obs-staging-bot
+%service_add_post obs-staging-bot.service
+
+%preun obs-staging-bot
+%service_del_preun obs-staging-bot.service
+
+%postun obs-staging-bot
+%service_del_postun obs-staging-bot.service
+
+%pre obs-status-service
+%service_add_pre obs-status-service.service
+
+%post obs-status-service
+%service_add_post obs-status-service.service
+
+%preun obs-status-service
+%service_del_preun obs-status-service.service
+
+%postun obs-status-service
+%service_del_postun obs-status-service.service
+
+%pre workflow-pr
+%service_add_pre workflow-direct@.service
+
+%post workflow-pr
+%service_add_post workflow-direct@.service
+
+%preun workflow-pr
+%service_del_preun workflow-direct@.service
+
+%postun workflow-pr
+%service_del_postun workflow-direct@.service
+
+%files devel-importer
+%license COPYING
+%doc devel-importer/README.md
+%{_bindir}/devel-importer
+
+%files doc
+%license COPYING
+%doc doc/README.md
+%doc doc/workflows.md
+
+%files gitea-events-rabbitmq-publisher
 %license COPYING
 %doc gitea-events-rabbitmq-publisher/README.md
 %{_bindir}/gitea-events-rabbitmq-publisher
 %{_unitdir}/gitea-events-rabbitmq-publisher.service
 
-%files -n doc
+%files gitea-status-proxy
 %license COPYING
-%doc doc/README.md
-%doc doc/workflows.md
+%{_bindir}/gitea_status_proxy
 
-%files -n devel-importer
-%license COPYING
-%doc devel-importer/README.md
-%{_bindir}/devel-importer
-
-%files -n group-review
+%files group-review
 %license COPYING
 %doc group-review/README.md
 %{_bindir}/group-review
+%{_unitdir}/group-review@.service
 
-%files -n obs-staging-bot
+%files obs-forward-bot
+%license COPYING
+%{_bindir}/obs-forward-bot
+
+%files obs-staging-bot
 %license COPYING
 %doc obs-staging-bot/README.md
 %{_bindir}/obs-staging-bot
+%{_unitdir}/obs-staging-bot.service
 
-%files -n obs-status-service
+%files obs-status-service
 %license COPYING
 %doc obs-status-service/README.md
 %{_bindir}/obs-status-service
+%{_unitdir}/obs-status-service.service
 
-%files -n workflow-direct
+%files utils
+%license COPYING
+%{_bindir}/hujson
+%{_bindir}/maintainer-update
+
+%files workflow-direct
 %license COPYING
 %doc workflow-direct/README.md
-#%{_bindir}/workflow-direct
+%{_bindir}/workflow-direct
+%{_unitdir}/workflow-direct@.service
 
-%files -n workflow-pr
+%files workflow-pr
 %license COPYING
 %doc workflow-pr/README.md
-#%{_bindir}/workflow-pr
+%{_bindir}/workflow-pr
 

common/associated_pr_scanner.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 )
 
-const PrPattern = "PR: %s/%s#%d"
+const PrPattern = "PR: %s/%s!%d"
 
 type BasicPR struct {
 	Org, Repo string
@@ -36,10 +36,14 @@ func parsePrLine(line string) (BasicPR, error) {
 		return ret, errors.New("missing / separator")
 	}
 
-	repo := strings.SplitN(org[1], "#", 2)
+	repo := strings.SplitN(org[1], "!", 2)
 	ret.Repo = repo[0]
 	if len(repo) != 2 {
-		return ret, errors.New("Missing # separator")
+		repo = strings.SplitN(org[1], "#", 2)
+		ret.Repo = repo[0]
+	}
+	if len(repo) != 2 {
+		return ret, errors.New("Missing ! or # separator")
 	}
 
 	// Gitea requires that each org and repo be [A-Za-z0-9_-]+

common/associated_pr_scanner_test.go

@@ -34,7 +34,7 @@ func TestAssociatedPRScanner(t *testing.T) {
 		},
 		{
 			"Multiple PRs",
-			"Some header of the issue\n\nFollowed by some description\nPR: test/foo#4\n\nPR: test/goo#5\n",
+			"Some header of the issue\n\nFollowed by some description\nPR: test/foo#4\n\nPR: test/goo!5\n",
 			[]common.BasicPR{
 				{Org: "test", Repo: "foo", Num: 4},
 				{Org: "test", Repo: "goo", Num: 5},
@@ -107,7 +107,7 @@ func TestAppendingPRsToDescription(t *testing.T) {
 			[]common.BasicPR{
 				{Org: "a", Repo: "b", Num: 100},
 			},
-			"something\n\nPR: a/b#100",
+			"something\n\nPR: a/b!100",
 		},
 		{
 			"Append multiple PR to end of description",
@@ -119,7 +119,7 @@ func TestAppendingPRsToDescription(t *testing.T) {
 				{Org: "b", Repo: "b", Num: 100},
 				{Org: "c", Repo: "b", Num: 100},
 			},
-			"something\n\nPR: a1/b#100\nPR: a1/c#100\nPR: a1/c#101\nPR: b/b#100\nPR: c/b#100",
+			"something\n\nPR: a1/b!100\nPR: a1/c!100\nPR: a1/c!101\nPR: b/b!100\nPR: c/b!100",
 		},
 		{
 			"Append multiple sorted PR to end of description and remove dups",
@@ -133,7 +133,7 @@ func TestAppendingPRsToDescription(t *testing.T) {
 				{Org: "a1", Repo: "c", Num: 101},
 				{Org: "a1", Repo: "b", Num: 100},
 			},
-			"something\n\nPR: a1/b#100\nPR: a1/c#100\nPR: a1/c#101\nPR: b/b#100\nPR: c/b#100",
+			"something\n\nPR: a1/b!100\nPR: a1/c!100\nPR: a1/c!101\nPR: b/b!100\nPR: c/b!100",
 		},
 	}
 

common/config.go

@@ -25,6 +25,7 @@ import (
 	"io"
 	"log"
 	"os"
+	"slices"
 	"strings"
 
 	"github.com/tailscale/hujson"
@@ -35,6 +36,9 @@ import (
 const (
 	ProjectConfigFile = "workflow.config"
 	StagingConfigFile = "staging.config"
+
+	Permission_ForceMerge = "force-merge"
+	Permission_Group      = "release-engineering"
 )
 
 type ConfigFile struct {
@@ -43,6 +47,7 @@ type ConfigFile struct {
 
 type ReviewGroup struct {
 	Name      string
+	Silent    bool // will not request reviews from group members
 	Reviewers []string
 }
 
@@ -51,14 +56,41 @@ type QAConfig struct {
 	Origin string
 }
 
+type Permissions struct {
+	Permission string
+	Members    []string
+}
+
+const (
+	Label_StagingAuto   = "staging/Auto"
+	Label_ReviewPending = "review/Pending"
+	Label_ReviewDone    = "review/Done"
+)
+
+func LabelKey(tag_value string) string {
+	// capitalize first letter and remove /
+	if len(tag_value) == 0 {
+		return ""
+	}
+	return strings.ToUpper(tag_value[0:1]) + strings.ReplaceAll(tag_value[1:], "/", "")
+}
+
 type AutogitConfig struct {
 	Workflows      []string // [pr, direct, test]
 	Organization   string
-	GitProjectName string   // Organization/GitProjectName.git is PrjGit
-	Branch         string   // branch name of PkgGit that aligns with PrjGit submodules
-	Reviewers      []string // only used by `pr` workflow
-	ReviewGroups   []ReviewGroup
+	GitProjectName string         // Organization/GitProjectName.git is PrjGit
+	Branch         string         // branch name of PkgGit that aligns with PrjGit submodules
+	Reviewers      []string       // only used by `pr` workflow
+	Permissions    []*Permissions // only used by `pr` workflow
+	ReviewGroups   []*ReviewGroup
 	Committers     []string // group in addition to Reviewers and Maintainers that can order the bot around, mostly as helper for factory-maintainers
+	Subdirs        []string // list of directories to sort submodules into. Needed b/c _manifest cannot list non-existent directories
+
+	Labels map[string]string // list of tags, if not default, to apply
+
+	NoProjectGitPR     bool // do not automatically create project git PRs, just assign reviewers and assume somethign else creates the ProjectGit PR
+	ManualMergeOnly    bool // only merge with "Merge OK" comment by Project Maintainers and/or Package Maintainers and/or reviewers
+	ManualMergeProject bool // require merge of ProjectGit PRs with "Merge OK" by ProjectMaintainers and/or reviewers
 }
 
 type AutogitConfigs []*AutogitConfig
@@ -172,6 +204,8 @@ func (configs AutogitConfigs) GetPrjGitConfig(org, repo, branch string) *Autogit
 		if c.GitProjectName == prjgit {
 			return c
 		}
+	}
+	for _, c := range configs {
 		if c.Organization == org && c.Branch == branch {
 			return c
 		}
@@ -180,6 +214,27 @@ func (configs AutogitConfigs) GetPrjGitConfig(org, repo, branch string) *Autogit
 	return nil
 }
 
+func (config *AutogitConfig) HasPermission(user, permission string) bool {
+	if config == nil {
+		return false
+	}
+
+	for _, p := range config.Permissions {
+		if p.Permission == permission {
+			if slices.Contains(p.Members, user) {
+				return true
+			}
+
+			for _, m := range p.Members {
+				if members, err := config.GetReviewGroupMembers(m); err == nil && slices.Contains(members, user) {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
 func (config *AutogitConfig) GetReviewGroupMembers(reviewer string) ([]string, error) {
 	for _, g := range config.ReviewGroups {
 		if g.Name == reviewer {
@@ -190,10 +245,19 @@ func (config *AutogitConfig) GetReviewGroupMembers(reviewer string) ([]string, e
 	return nil, errors.New("User " + reviewer + " not found as group reviewer for " + config.GitProjectName)
 }
 
+func (config *AutogitConfig) GetReviewGroup(reviewer string) (*ReviewGroup, error) {
+	for _, g := range config.ReviewGroups {
+		if g.Name == reviewer {
+			return g, nil
+		}
+	}
+	return nil, errors.New("User " + reviewer + " not found as group reviewer for " + config.GitProjectName)
+}
+
 func (config *AutogitConfig) GetPrjGit() (string, string, string) {
 	org := config.Organization
 	repo := DefaultGitPrj
-	branch := "master"
+	branch := ""
 
 	a := strings.Split(config.GitProjectName, "/")
 	if len(a[0]) > 0 {
@@ -217,6 +281,9 @@ func (config *AutogitConfig) GetPrjGit() (string, string, string) {
 		}
 	}
 
+	if len(branch) == 0 {
+		panic("branch for project is undefined. Should not happend." + org + "/" + repo)
+	}
 	return org, repo, branch
 }
 
@@ -224,6 +291,14 @@ func (config *AutogitConfig) GetRemoteBranch() string {
 	return "origin_" + config.Branch
 }
 
+func (config *AutogitConfig) Label(label string) string {
+		if t, found := config.Labels[LabelKey(label)]; found {
+			return t
+		}
+
+	return label
+}
+
 type StagingConfig struct {
 	ObsProject   string
 	RebuildAll   bool
@@ -236,6 +311,9 @@ type StagingConfig struct {
 
 func ParseStagingConfig(data []byte) (*StagingConfig, error) {
 	var staging StagingConfig
+	if len(data) == 0 {
+		return nil, errors.New("non-existent config file.")
+	}
 	data, err := hujson.Standardize(data)
 	if err != nil {
 		return nil, err

common/config_test.go

@@ -10,6 +10,146 @@ import (
 	mock_common "src.opensuse.org/autogits/common/mock"
 )
 
+func TestLabelKey(t *testing.T) {
+	tests := map[string]string{
+		"":        "",
+		"foo":     "Foo",
+		"foo/bar": "Foobar",
+		"foo/Bar": "FooBar",
+	}
+
+	for k, v := range tests {
+		if c := common.LabelKey(k); c != v {
+			t.Error("expected", v, "got", c, "input", k)
+		}
+	}
+}
+
+func TestConfigLabelParser(t *testing.T) {
+	tests := []struct {
+		name        string
+		json        string
+		label_value string
+	}{
+		{
+			name:        "empty",
+			json:        "{}",
+			label_value: "path/String",
+		},
+		{
+			name:        "defined",
+			json:        `{"Labels": {"foo": "bar", "PathString": "moo/Label"}}`,
+			label_value: "moo/Label",
+		},
+		{
+			name:        "undefined",
+			json:        `{"Labels": {"foo": "bar", "NotPathString": "moo/Label"}}`,
+			label_value: "path/String",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			repo := models.Repository{
+				DefaultBranch: "master",
+			}
+
+			ctl := gomock.NewController(t)
+			gitea := mock_common.NewMockGiteaFileContentAndRepoFetcher(ctl)
+			gitea.EXPECT().GetRepositoryFileContent("foo", "bar", "", "workflow.config").Return([]byte(test.json), "abc", nil)
+			gitea.EXPECT().GetRepository("foo", "bar").Return(&repo, nil)
+
+			config, err := common.ReadWorkflowConfig(gitea, "foo/bar")
+			if err != nil || config == nil {
+				t.Fatal(err)
+			}
+
+			if l := config.Label("path/String"); l != test.label_value {
+				t.Error("Expecting", test.label_value, "got", l)
+			}
+		})
+	}
+}
+
+func TestProjectConfigMatcher(t *testing.T) {
+	configs := common.AutogitConfigs{
+		{
+			Organization:   "test",
+			GitProjectName: "test/prjgit#main",
+		},
+		{
+			Organization:   "test",
+			Branch:         "main",
+			GitProjectName: "test/prjgit#main",
+		},
+		{
+			Organization:   "test",
+			Branch:         "main",
+			GitProjectName: "test/bar#never_match",
+		},
+		{
+			Organization:   "test",
+			GitProjectName: "test/bar#main",
+		},
+	}
+
+	tests := []struct {
+		name   string
+		org    string
+		repo   string
+		branch string
+		config int
+	}{
+		{
+			name:   "invalid match",
+			org:    "foo",
+			repo:   "bar",
+			config: -1,
+		},
+		{
+			name:   "default branch",
+			org:    "test",
+			repo:   "foo",
+			branch: "",
+			config: 0,
+		},
+		{
+			name:   "main branch",
+			org:    "test",
+			repo:   "foo",
+			branch: "main",
+			config: 1,
+		},
+		{
+			name:   "prjgit only match",
+			org:    "test",
+			repo:   "bar",
+			branch: "main",
+			config: 3,
+		},
+		{
+			name:   "non-default branch match",
+			org:    "test",
+			repo:   "bar",
+			branch: "something_main",
+			config: -1,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			c := configs.GetPrjGitConfig(test.org, test.repo, test.branch)
+			if test.config < 0 {
+				if c != nil {
+					t.Fatal("Expected nil. Got:", *c)
+				}
+			} else if config := configs[test.config]; c != config {
+				t.Fatal("Expected", *config, "got", *c)
+			}
+		})
+	}
+}
+
 func TestConfigWorkflowParser(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -41,14 +181,23 @@ func TestConfigWorkflowParser(t *testing.T) {
 			gitea.EXPECT().GetRepositoryFileContent("foo", "bar", "", "workflow.config").Return([]byte(test.config_json), "abc", nil)
 			gitea.EXPECT().GetRepository("foo", "bar").Return(&test.repo, nil)
 
-			_, err := common.ReadWorkflowConfig(gitea, "foo/bar")
+			config, err := common.ReadWorkflowConfig(gitea, "foo/bar")
 			if err != nil {
 				t.Fatal(err)
 			}
+
+			if config.ManualMergeOnly != false {
+				t.Fatal("This should be false")
+			}
+
+			if config.Label("foobar") != "foobar" {
+				t.Fatal("undefined label should return default value")
+			}
 		})
 	}
 }
 
+// FIXME: should test ReadWorkflowConfig as it will always set prjgit completely
 func TestProjectGitParser(t *testing.T) {
 	tests := []struct {
 		name   string
@@ -59,20 +208,21 @@ func TestProjectGitParser(t *testing.T) {
 	}{
 		{
 			name:   "repo only",
-			prjgit: "repo.git",
+			prjgit: "repo.git#master",
 			org:    "org",
 			branch: "br",
 			res:    [3]string{"org", "repo.git", "master"},
 		},
 		{
-			name: "default",
-			org:  "org",
-			res:  [3]string{"org", common.DefaultGitPrj, "master"},
+			name:   "default",
+			org:    "org",
+			prjgit: "org/_ObsPrj#master",
+			res:    [3]string{"org", common.DefaultGitPrj, "master"},
 		},
 		{
 			name:   "repo with branch",
 			org:    "org2",
-			prjgit: "repo.git#somebranch",
+			prjgit: "org2/repo.git#somebranch",
 			res:    [3]string{"org2", "repo.git", "somebranch"},
 		},
 		{
@@ -82,32 +232,32 @@ func TestProjectGitParser(t *testing.T) {
 			res:    [3]string{"oorg", "foo.bar", "point"},
 		},
 		{
-			name: "whitespace shouldn't matter",
+			name:   "whitespace shouldn't matter",
 			prjgit: "  oorg  / \nfoo.bar\t  #   point ",
 			res:    [3]string{"oorg", "foo.bar", "point"},
 		},
 		{
 			name:   "repo org and empty branch",
 			org:    "org3",
-			prjgit: "oorg/foo.bar#",
+			prjgit: "oorg/foo.bar#master",
 			res:    [3]string{"oorg", "foo.bar", "master"},
 		},
 		{
 			name:   "only branch defined",
 			org:    "org3",
-			prjgit: "#mybranch",
+			prjgit: "org3/_ObsPrj#mybranch",
 			res:    [3]string{"org3", "_ObsPrj", "mybranch"},
 		},
 		{
 			name:   "only org and branch defined",
 			org:    "org3",
-			prjgit: "org1/#mybranch",
+			prjgit: "org1/_ObsPrj#mybranch",
 			res:    [3]string{"org1", "_ObsPrj", "mybranch"},
 		},
 		{
 			name:   "empty org and repo",
 			org:    "org3",
-			prjgit: "/repo#",
+			prjgit: "org3/repo#master",
 			res:    [3]string{"org3", "repo", "master"},
 		},
 	}
@@ -128,3 +278,67 @@ func TestProjectGitParser(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigPermissions(t *testing.T) {
+	tests := []struct {
+		name       string
+		permission string
+		user       string
+		config     *common.AutogitConfig
+		result     bool
+	}{
+		{
+			name:       "NoPermissions",
+			permission: common.Permission_ForceMerge,
+		},
+		{
+			name:       "NoPermissions",
+			permission: common.Permission_Group,
+		},
+		{
+			name:       "Regular permission ForcePush",
+			permission: common.Permission_ForceMerge,
+			result:     true,
+			user:       "user",
+			config: &common.AutogitConfig{
+				Permissions: []*common.Permissions{
+					&common.Permissions{
+						Permission: common.Permission_ForceMerge,
+						Members:    []string{"user"},
+					},
+				},
+			},
+		},
+		{
+			name:       "User is part of a group",
+			permission: common.Permission_ForceMerge,
+			result:     true,
+			user:       "user",
+			config: &common.AutogitConfig{
+				Permissions: []*common.Permissions{
+					&common.Permissions{
+						Permission: common.Permission_ForceMerge,
+						Members:    []string{"group"},
+					},
+				},
+				ReviewGroups: []*common.ReviewGroup{
+					&common.ReviewGroup{
+						Name:      "group",
+						Reviewers: []string{"some", "members", "including", "user"},
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if r := test.config.HasPermission(test.user, test.permission); r != test.result {
+				t.Error("Expecting", test.result, "but got opposite")
+			}
+			if r := test.config.HasPermission(test.user+test.user, test.permission); r {
+				t.Error("Expecting false for fake user, but got opposite")
+			}
+		})
+	}
+}

common/conststring_test.go

@@ -1731,3 +1731,246 @@ const requestedReviewJSON = `{
   "commit_id": "",
   "review": null
 }`
+
+const requestStatusJSON=`{
+  "commit": {
+    "id": "e637d86cbbdd438edbf60148e28f9d75a74d51b27b01f75610f247cd18394c8e",
+    "message": "Update nodejs-common.changes\n",
+    "url": "https://src.opensuse.org/autogits/nodejs-common/commit/e637d86cbbdd438edbf60148e28f9d75a74d51b27b01f75610f247cd18394c8e",
+    "author": {
+      "name": "Adam Majer",
+      "email": "adamm@noreply.src.opensuse.org",
+      "username": "adamm"
+    },
+    "committer": {
+      "name": "Adam Majer",
+      "email": "adamm@noreply.src.opensuse.org",
+      "username": "adamm"
+    },
+    "verification": null,
+    "timestamp": "2025-09-16T12:41:02+02:00",
+    "added": [],
+    "removed": [],
+    "modified": [
+      "nodejs-common.changes"
+    ]
+  },
+  "context": "test",
+  "created_at": "2025-09-16T10:50:32Z",
+  "description": "",
+  "id": 21663,
+  "repository": {
+    "id": 90520,
+    "owner": {
+      "id": 983,
+      "login": "autogits",
+      "login_name": "",
+      "source_id": 0,
+      "full_name": "",
+      "email": "",
+      "avatar_url": "https://src.opensuse.org/avatars/80a61ef3a14c3c22f0b8b1885d1a75d4",
+      "html_url": "https://src.opensuse.org/autogits",
+      "language": "",
+      "is_admin": false,
+      "last_login": "0001-01-01T00:00:00Z",
+      "created": "2024-06-20T09:46:37+02:00",
+      "restricted": false,
+      "active": false,
+      "prohibit_login": false,
+      "location": "",
+      "website": "",
+      "description": "",
+      "visibility": "public",
+      "followers_count": 0,
+      "following_count": 0,
+      "starred_repos_count": 0,
+      "username": "autogits"
+    },
+    "name": "nodejs-common",
+    "full_name": "autogits/nodejs-common",
+    "description": "",
+    "empty": false,
+    "private": false,
+    "fork": true,
+    "template": false,
+    "parent": {
+      "id": 62649,
+      "owner": {
+        "id": 64,
+        "login": "pool",
+        "login_name": "",
+        "source_id": 0,
+        "full_name": "",
+        "email": "",
+        "avatar_url": "https://src.opensuse.org/avatars/b10a8c0bede9eb4ea771b04db3149f28",
+        "html_url": "https://src.opensuse.org/pool",
+        "language": "",
+        "is_admin": false,
+        "last_login": "0001-01-01T00:00:00Z",
+        "created": "2023-03-01T14:41:17+01:00",
+        "restricted": false,
+        "active": false,
+        "prohibit_login": false,
+        "location": "",
+        "website": "",
+        "description": "",
+        "visibility": "public",
+        "followers_count": 2,
+        "following_count": 0,
+        "starred_repos_count": 0,
+        "username": "pool"
+      },
+      "name": "nodejs-common",
+      "full_name": "pool/nodejs-common",
+      "description": "",
+      "empty": false,
+      "private": false,
+      "fork": false,
+      "template": false,
+      "mirror": false,
+      "size": 134,
+      "language": "",
+      "languages_url": "https://src.opensuse.org/api/v1/repos/pool/nodejs-common/languages",
+      "html_url": "https://src.opensuse.org/pool/nodejs-common",
+      "url": "https://src.opensuse.org/api/v1/repos/pool/nodejs-common",
+      "link": "",
+      "ssh_url": "gitea@src.opensuse.org:pool/nodejs-common.git",
+      "clone_url": "https://src.opensuse.org/pool/nodejs-common.git",
+      "original_url": "",
+      "website": "",
+      "stars_count": 0,
+      "forks_count": 3,
+      "watchers_count": 12,
+      "open_issues_count": 0,
+      "open_pr_counter": 0,
+      "release_counter": 0,
+      "default_branch": "factory",
+      "archived": false,
+      "created_at": "2024-06-17T17:08:45+02:00",
+      "updated_at": "2025-08-21T21:58:31+02:00",
+      "archived_at": "1970-01-01T01:00:00+01:00",
+      "permissions": {
+        "admin": true,
+        "push": true,
+        "pull": true
+      },
+      "has_issues": true,
+      "internal_tracker": {
+        "enable_time_tracker": false,
+        "allow_only_contributors_to_track_time": true,
+        "enable_issue_dependencies": true
+      },
+      "has_wiki": false,
+      "has_pull_requests": true,
+      "has_projects": false,
+      "projects_mode": "all",
+      "has_releases": false,
+      "has_packages": false,
+      "has_actions": false,
+      "ignore_whitespace_conflicts": false,
+      "allow_merge_commits": true,
+      "allow_rebase": true,
+      "allow_rebase_explicit": true,
+      "allow_squash_merge": true,
+      "allow_fast_forward_only_merge": true,
+      "allow_rebase_update": true,
+      "allow_manual_merge": true,
+      "autodetect_manual_merge": true,
+      "default_delete_branch_after_merge": false,
+      "default_merge_style": "merge",
+      "default_allow_maintainer_edit": false,
+      "avatar_url": "",
+      "internal": false,
+      "mirror_interval": "",
+      "object_format_name": "sha256",
+      "mirror_updated": "0001-01-01T00:00:00Z",
+      "topics": [],
+      "licenses": []
+    },
+    "mirror": false,
+    "size": 143,
+    "language": "",
+    "languages_url": "https://src.opensuse.org/api/v1/repos/autogits/nodejs-common/languages",
+    "html_url": "https://src.opensuse.org/autogits/nodejs-common",
+    "url": "https://src.opensuse.org/api/v1/repos/autogits/nodejs-common",
+    "link": "",
+    "ssh_url": "gitea@src.opensuse.org:autogits/nodejs-common.git",
+    "clone_url": "https://src.opensuse.org/autogits/nodejs-common.git",
+    "original_url": "",
+    "website": "",
+    "stars_count": 0,
+    "forks_count": 1,
+    "watchers_count": 4,
+    "open_issues_count": 0,
+    "open_pr_counter": 1,
+    "release_counter": 0,
+    "default_branch": "factory",
+    "archived": false,
+    "created_at": "2024-07-01T13:29:03+02:00",
+    "updated_at": "2025-09-16T12:41:03+02:00",
+    "archived_at": "1970-01-01T01:00:00+01:00",
+    "permissions": {
+      "admin": true,
+      "push": true,
+      "pull": true
+    },
+    "has_issues": false,
+    "has_wiki": false,
+    "has_pull_requests": true,
+    "has_projects": false,
+    "projects_mode": "all",
+    "has_releases": false,
+    "has_packages": false,
+    "has_actions": false,
+    "ignore_whitespace_conflicts": false,
+    "allow_merge_commits": true,
+    "allow_rebase": true,
+    "allow_rebase_explicit": true,
+    "allow_squash_merge": true,
+    "allow_fast_forward_only_merge": true,
+    "allow_rebase_update": true,
+    "allow_manual_merge": true,
+    "autodetect_manual_merge": true,
+    "default_delete_branch_after_merge": false,
+    "default_merge_style": "merge",
+    "default_allow_maintainer_edit": false,
+    "avatar_url": "",
+    "internal": false,
+    "mirror_interval": "",
+    "object_format_name": "sha256",
+    "mirror_updated": "0001-01-01T00:00:00Z",
+    "topics": [],
+    "licenses": [
+      "MIT"
+    ]
+  },
+  "sender": {
+    "id": 129,
+    "login": "adamm",
+    "login_name": "",
+    "source_id": 0,
+    "full_name": "Adam Majer",
+    "email": "adamm@noreply.src.opensuse.org",
+    "avatar_url": "https://src.opensuse.org/avatars/3e8917bfbf04293f7c20c28cacd83dae2ba9b78a6c6a9a1bedf14c683d8a3763",
+    "html_url": "https://src.opensuse.org/adamm",
+    "language": "",
+    "is_admin": false,
+    "last_login": "0001-01-01T00:00:00Z",
+    "created": "2023-07-21T16:43:48+02:00",
+    "restricted": false,
+    "active": false,
+    "prohibit_login": false,
+    "location": "",
+    "website": "",
+    "description": "",
+    "visibility": "public",
+    "followers_count": 1,
+    "following_count": 0,
+    "starred_repos_count": 0,
+    "username": "adamm"
+  },
+  "sha": "e637d86cbbdd438edbf60148e28f9d75a74d51b27b01f75610f247cd18394c8e",
+  "state": "pending",
+  "target_url": "https://src.opensuse.org/",
+  "updated_at": "2025-09-16T10:50:32Z"
+}`

common/git_utils.go

@@ -40,10 +40,18 @@ type GitSubmoduleLister interface {
 	GitSubmoduleCommitId(cwd, packageName, commitId string) (subCommitId string, valid bool)
 }
 
+type GitDirectoryLister interface {
+	GitDirectoryList(gitPath, commitId string) (dirlist map[string]string, err error)
+}
+
 type GitStatusLister interface {
 	GitStatus(cwd string) ([]GitStatusData, error)
 }
 
+type GitDiffLister interface {
+	GitDiff(cwd, base, head string) (string, error)
+}
+
 type Git interface {
 	// error if git, but wrong remote
 	GitClone(repo, branch, remoteUrl string) (string, error) // clone, or check if path is already checked out remote and force pulls, error otherwise. Return remotename, errror
@@ -57,12 +65,16 @@ type Git interface {
 	io.Closer
 
 	GitSubmoduleLister
+	GitDirectoryLister
 	GitStatusLister
 
 	GitExecWithOutputOrPanic(cwd string, params ...string) string
 	GitExecOrPanic(cwd string, params ...string)
 	GitExec(cwd string, params ...string) error
 	GitExecWithOutput(cwd string, params ...string) (string, error)
+	GitExecQuietOrPanic(cwd string, params ...string)
+
+	GitDiffLister
 }
 
 type GitHandlerImpl struct {
@@ -70,7 +82,8 @@ type GitHandlerImpl struct {
 	GitCommiter string
 	GitEmail    string
 
-	lock *sync.Mutex
+	lock  *sync.Mutex
+	quiet bool
 }
 
 func (s *GitHandlerImpl) GetPath() string {
@@ -133,6 +146,7 @@ func (s *gitHandlerGeneratorImpl) CreateGitHandler(org string) (Git, error) {
 }
 
 func (s *gitHandlerGeneratorImpl) ReadExistingPath(org string) (Git, error) {
+	LogDebug("Locking git org:", org)
 	s.lock_lock.Lock()
 	defer s.lock_lock.Unlock()
 
@@ -154,6 +168,7 @@ func (s *gitHandlerGeneratorImpl) ReadExistingPath(org string) (Git, error) {
 func (s *gitHandlerGeneratorImpl) ReleaseLock(org string) {
 	m, ok := s.lock[org]
 	if ok {
+		LogDebug("Unlocking git org:", org)
 		m.Unlock()
 	}
 }
@@ -203,7 +218,7 @@ func (e *GitHandlerImpl) GitClone(repo, branch, remoteUrl string) (string, error
 		return "", fmt.Errorf("Cannot parse remote URL: %w", err)
 	}
 	remoteBranch := "HEAD"
-	if len(branch) == 0 && remoteUrlComp != nil {
+	if len(branch) == 0 && remoteUrlComp != nil && remoteUrlComp.Commit != "HEAD" {
 		branch = remoteUrlComp.Commit
 		remoteBranch = branch
 	} else if len(branch) > 0 {
@@ -232,46 +247,51 @@ func (e *GitHandlerImpl) GitClone(repo, branch, remoteUrl string) (string, error
 
 		// check if we have submodule to deinit
 		if list, _ := e.GitSubmoduleList(repo, "HEAD"); len(list) > 0 {
-			e.GitExecOrPanic(repo, "submodule", "deinit", "--all", "--force")
+			e.GitExecQuietOrPanic(repo, "submodule", "deinit", "--all", "--force")
 		}
 
-		e.GitExecOrPanic(repo, "fetch", remoteName, remoteBranch)
+		e.GitExecOrPanic(repo, "fetch", "--prune", remoteName, remoteBranch)
 	}
+	/*
+		refsBytes, err := os.ReadFile(path.Join(e.GitPath, repo, ".git/refs/remotes", remoteName, "HEAD"))
+		if err != nil {
+			LogError("Cannot read HEAD of remote", remoteName)
+			return remoteName, fmt.Errorf("Cannot read HEAD of remote %s", remoteName)
+		}
 
-	refsBytes, err := os.ReadFile(path.Join(e.GitPath, repo, ".git/refs/remotes", remoteName, "HEAD"))
-	if err != nil {
-		LogError("Cannot read HEAD of remote", remoteName)
-		return remoteName, fmt.Errorf("Cannot read HEAD of remote %s", remoteName)
-	}
+		refs := string(refsBytes)
+		if refs[0:5] != "ref: " {
+			LogError("Unexpected format of remote HEAD ref:", refs)
+			return remoteName, fmt.Errorf("Unexpected format of remote HEAD ref: %s", refs)
+		}
 
-	refs := string(refsBytes)
-	if refs[0:5] != "ref: " {
-		LogError("Unexpected format of remote HEAD ref:", refs)
-		return remoteName, fmt.Errorf("Unexpected format of remote HEAD ref: %s", refs)
-	}
-
-	if len(branch) == 0 || branch == "HEAD" {
-		remoteRef = strings.TrimSpace(refs[5:])
-		branch = remoteRef[strings.LastIndex(remoteRef, "/")+1:]
-		LogDebug("remoteRef", remoteRef)
-		LogDebug("branch", branch)
-	}
-
-	args := []string{"fetch", remoteName, branch}
+		if len(branch) == 0 || branch == "HEAD" {
+			remoteRef = strings.TrimSpace(refs[5:])
+			branch = remoteRef[strings.LastIndex(remoteRef, "/")+1:]
+			LogDebug("remoteRef", remoteRef)
+			LogDebug("branch", branch)
+		}
+	*/
+	args := []string{"fetch", "--prune", remoteName, branch}
 	if strings.TrimSpace(e.GitExecWithOutputOrPanic(repo, "rev-parse", "--is-shallow-repository")) == "true" {
 		args = slices.Insert(args, 1, "--unshallow")
 	}
 	e.GitExecOrPanic(repo, args...)
-	return remoteName, e.GitExec(repo, "checkout", "--track", "-B", branch, remoteRef)
+	return remoteName, e.GitExec(repo, "checkout", "-f", "--track", "-B", branch, remoteRef)
 }
 
 func (e *GitHandlerImpl) GitBranchHead(gitDir, branchName string) (string, error) {
-	id, err := e.GitExecWithOutput(gitDir, "show-ref", "--hash", "--verify", "refs/heads/"+branchName)
+	id, err := e.GitExecWithOutput(gitDir, "show-ref", "--heads", "--hash", branchName)
 	if err != nil {
 		return "", fmt.Errorf("Can't find default branch: %s", branchName)
 	}
 
-	return strings.TrimSpace(id), nil
+	id = strings.TrimSpace(SplitLines(id)[0])
+	if len(id) < 10 {
+		return "", fmt.Errorf("Can't find branch: %s", branchName)
+	}
+
+	return id, nil
 }
 
 func (e *GitHandlerImpl) GitRemoteHead(gitDir, remote, branchName string) (string, error) {
@@ -284,6 +304,7 @@ func (e *GitHandlerImpl) GitRemoteHead(gitDir, remote, branchName string) (strin
 }
 
 func (e *GitHandlerImpl) Close() error {
+	LogDebug("Unlocking git lock")
 	e.lock.Unlock()
 	return nil
 }
@@ -329,6 +350,10 @@ var ExtraGitParams []string
 
 func (e *GitHandlerImpl) GitExecWithOutput(cwd string, params ...string) (string, error) {
 	cmd := exec.Command("/usr/bin/git", params...)
+	var identityFile string
+	if i := os.Getenv("AUTOGITS_IDENTITY_FILE"); len(i) > 0 {
+		identityFile = " -i " + i
+	}
 	cmd.Env = []string{
 		"GIT_CEILING_DIRECTORIES=" + e.GitPath,
 		"GIT_CONFIG_GLOBAL=/dev/null",
@@ -336,7 +361,8 @@ func (e *GitHandlerImpl) GitExecWithOutput(cwd string, params ...string) (string
 		"GIT_COMMITTER_NAME=" + e.GitCommiter,
 		"EMAIL=not@exist@src.opensuse.org",
 		"GIT_LFS_SKIP_SMUDGE=1",
-		"GIT_SSH_COMMAND=/usr/bin/ssh -o StrictHostKeyChecking=yes",
+		"GIT_LFS_SKIP_PUSH=1",
+		"GIT_SSH_COMMAND=/usr/bin/ssh -o StrictHostKeyChecking=yes" + identityFile,
 	}
 	if len(ExtraGitParams) > 0 {
 		cmd.Env = append(cmd.Env, ExtraGitParams...)
@@ -346,7 +372,9 @@ func (e *GitHandlerImpl) GitExecWithOutput(cwd string, params ...string) (string
 
 	LogDebug("git execute @", cwd, ":", cmd.Args)
 	out, err := cmd.CombinedOutput()
-	LogDebug(string(out))
+	if !e.quiet {
+		LogDebug(string(out))
+	}
 	if err != nil {
 		LogError("git", cmd.Args, " error:", err)
 		return "", fmt.Errorf("error executing: git %#v \n%s\n err: %w", cmd.Args, out, err)
@@ -355,6 +383,13 @@ func (e *GitHandlerImpl) GitExecWithOutput(cwd string, params ...string) (string
 	return string(out), nil
 }
 
+func (e *GitHandlerImpl) GitExecQuietOrPanic(cwd string, params ...string) {
+	e.quiet = true
+	e.GitExecOrPanic(cwd, params...)
+	e.quiet = false
+	return
+}
+
 type ChanIO struct {
 	ch chan byte
 }
@@ -752,6 +787,80 @@ func (e *GitHandlerImpl) GitCatFile(cwd, commitId, filename string) (data []byte
 	return
 }
 
+// return (filename) -> (hash) map for all submodules
+func (e *GitHandlerImpl) GitDirectoryList(gitPath, commitId string) (directoryList map[string]string, err error) {
+	var done sync.Mutex
+	directoryList = make(map[string]string)
+
+	done.Lock()
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
+
+	LogDebug("Getting directory for:", commitId)
+
+	go func() {
+		defer done.Unlock()
+		defer close(data_out.ch)
+
+		data_out.Write([]byte(commitId))
+		data_out.ch <- '\x00'
+		var c GitCommit
+		c, err = parseGitCommit(data_in.ch)
+		if err != nil {
+			err = fmt.Errorf("Error parsing git commit. Err: %w", err)
+			return
+		}
+
+		trees := make(map[string]string)
+		trees[""] = c.Tree
+
+		for len(trees) > 0 {
+			for p, tree := range trees {
+				delete(trees, p)
+
+				data_out.Write([]byte(tree))
+				data_out.ch <- '\x00'
+				var tree GitTree
+				tree, err = parseGitTree(data_in.ch)
+
+				if err != nil {
+					err = fmt.Errorf("Error parsing git tree: %w", err)
+					return
+				}
+
+				for _, te := range tree.items {
+					if te.isTree() {
+						directoryList[p+te.name] = te.hash
+					}
+				}
+			}
+		}
+	}()
+
+	cmd := exec.Command("/usr/bin/git", "cat-file", "--batch", "-Z")
+	cmd.Env = []string{
+		"GIT_CEILING_DIRECTORIES=" + e.GitPath,
+		"GIT_LFS_SKIP_SMUDGE=1",
+		"GIT_CONFIG_GLOBAL=/dev/null",
+	}
+	cmd.Dir = filepath.Join(e.GitPath, gitPath)
+	cmd.Stdout = &data_in
+	cmd.Stdin = &data_out
+	cmd.Stderr = writeFunc(func(data []byte) (int, error) {
+		LogError(string(data))
+		return len(data), nil
+	})
+	LogDebug("command run:", cmd.Args)
+	if e := cmd.Run(); e != nil {
+		LogError(e)
+		close(data_in.ch)
+		close(data_out.ch)
+		return directoryList, e
+	}
+
+	done.Lock()
+	return directoryList, err
+}
+
 // return (filename) -> (hash) map for all submodules
 func (e *GitHandlerImpl) GitSubmoduleList(gitPath, commitId string) (submoduleList map[string]string, err error) {
 	var done sync.Mutex
@@ -760,6 +869,8 @@ func (e *GitHandlerImpl) GitSubmoduleList(gitPath, commitId string) (submoduleLi
 	done.Lock()
 	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 
+	LogDebug("Getting submodules for:", commitId)
+
 	go func() {
 		defer done.Unlock()
 		defer close(data_out.ch)
@@ -837,7 +948,7 @@ func (e *GitHandlerImpl) GitSubmoduleCommitId(cwd, packageName, commitId string)
 	go func() {
 		defer func() {
 			if recover() != nil {
-				subCommitId = "wrong"
+				subCommitId = ""
 				commitId = "ok"
 				valid = false
 			}
@@ -892,7 +1003,7 @@ func (e *GitHandlerImpl) GitSubmoduleCommitId(cwd, packageName, commitId string)
 	}
 
 	wg.Wait()
-	return subCommitId, len(subCommitId) == len(commitId)
+	return subCommitId, len(subCommitId) > 0
 }
 
 const (
@@ -907,6 +1018,16 @@ type GitStatusData struct {
 	Path   string
 	Status int
 	States [3]string
+
+	/*
+	 <sub> A 4 character field describing the submodule state.
+	            "N..." when the entry is not a submodule.
+	            "S<c><m><u>" when the entry is a submodule.
+	            <c> is "C" if the commit changed; otherwise ".".
+	            <m> is "M" if it has tracked changes; otherwise ".".
+	            <u> is "U" if there are untracked changes; otherwise ".".
+	*/
+	SubmoduleChanges string
 }
 
 func parseGitStatusHexString(data io.ByteReader) (string, error) {
@@ -929,6 +1050,20 @@ func parseGitStatusHexString(data io.ByteReader) (string, error) {
 	}
 }
 func parseGitStatusString(data io.ByteReader) (string, error) {
+	str := make([]byte, 0, 100)
+	for {
+		c, err := data.ReadByte()
+		if err != nil {
+			return "", errors.New("Unexpected EOF. Expected NUL string term")
+		}
+		if c == 0 || c == ' ' {
+			return string(str), nil
+		}
+		str = append(str, c)
+	}
+}
+
+func parseGitStatusStringWithSpace(data io.ByteReader) (string, error) {
 	str := make([]byte, 0, 100)
 	for {
 		c, err := data.ReadByte()
@@ -969,7 +1104,7 @@ func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
 			return nil, err
 		}
 		ret.Status = GitStatus_Modified
-		ret.Path, err = parseGitStatusString(data)
+		ret.Path, err = parseGitStatusStringWithSpace(data)
 		if err != nil {
 			return nil, err
 		}
@@ -979,11 +1114,11 @@ func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
 			return nil, err
 		}
 		ret.Status = GitStatus_Renamed
-		ret.Path, err = parseGitStatusString(data)
+		ret.Path, err = parseGitStatusStringWithSpace(data)
 		if err != nil {
 			return nil, err
 		}
-		ret.States[0], err = parseGitStatusString(data)
+		ret.States[0], err = parseGitStatusStringWithSpace(data)
 		if err != nil {
 			return nil, err
 		}
@@ -993,7 +1128,7 @@ func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
 			return nil, err
 		}
 		ret.Status = GitStatus_Untracked
-		ret.Path, err = parseGitStatusString(data)
+		ret.Path, err = parseGitStatusStringWithSpace(data)
 		if err != nil {
 			return nil, err
 		}
@@ -1003,15 +1138,22 @@ func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
 			return nil, err
 		}
 		ret.Status = GitStatus_Ignored
-		ret.Path, err = parseGitStatusString(data)
+		ret.Path, err = parseGitStatusStringWithSpace(data)
 		if err != nil {
 			return nil, err
 		}
 	case 'u':
 		var err error
-		if err = skipGitStatusEntry(data, 7); err != nil {
+		if err = skipGitStatusEntry(data, 2); err != nil {
 			return nil, err
 		}
+		if ret.SubmoduleChanges, err = parseGitStatusString(data); err != nil {
+			return nil, err
+		}
+		if err = skipGitStatusEntry(data, 4); err != nil {
+			return nil, err
+		}
+
 		if ret.States[0], err = parseGitStatusHexString(data); err != nil {
 			return nil, err
 		}
@@ -1022,7 +1164,7 @@ func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
 			return nil, err
 		}
 		ret.Status = GitStatus_Unmerged
-		ret.Path, err = parseGitStatusString(data)
+		ret.Path, err = parseGitStatusStringWithSpace(data)
 		if err != nil {
 			return nil, err
 		}
@@ -1069,3 +1211,26 @@ func (e *GitHandlerImpl) GitStatus(cwd string) (ret []GitStatusData, err error)
 
 	return parseGitStatusData(bufio.NewReader(bytes.NewReader(out)))
 }
+
+func (e *GitHandlerImpl) GitDiff(cwd, base, head string) (string, error) {
+	LogDebug("getting diff from", base, "..", head)
+
+	cmd := exec.Command("/usr/bin/git", "diff", base+".."+head)
+	cmd.Env = []string{
+		"GIT_CEILING_DIRECTORIES=" + e.GitPath,
+		"GIT_LFS_SKIP_SMUDGE=1",
+		"GIT_CONFIG_GLOBAL=/dev/null",
+	}
+	cmd.Dir = filepath.Join(e.GitPath, cwd)
+	cmd.Stderr = writeFunc(func(data []byte) (int, error) {
+		LogError(string(data))
+		return len(data), nil
+	})
+	LogDebug("command run:", cmd.Args)
+	out, err := cmd.Output()
+	if err != nil {
+		LogError("Error running command", cmd.Args, err)
+	}
+
+	return string(out), nil
+}

common/git_utils_test.go

@@ -392,6 +392,7 @@ func TestCommitTreeParsing(t *testing.T) {
 		commitId = commitId + strings.TrimSpace(string(data))
 		return len(data), nil
 	})
+	cmd.Stderr = os.Stderr
 	if err := cmd.Run(); err != nil {
 		t.Fatal(err.Error())
 	}
@@ -555,6 +556,8 @@ func TestGitStatusParse(t *testing.T) {
 					Path:   ".gitmodules",
 					Status: GitStatus_Unmerged,
 					States: [3]string{"587ec403f01113f2629da538f6e14b84781f70ac59c41aeedd978ea8b1253a76", "d23eb05d9ca92883ab9f4d28f3ec90c05f667f3a5c8c8e291bd65e03bac9ae3c", "087b1d5f22dbf0aa4a879fff27fff03568b334c90daa5f2653f4a7961e24ea33"},
+
+					SubmoduleChanges: "N...",
 				},
 			},
 		},

common/gitea_utils.go

@@ -29,7 +29,7 @@ import (
 	"path"
 	"path/filepath"
 	"slices"
-	"strings"
+	"sync"
 	"time"
 
 	transport "github.com/go-openapi/runtime/client"
@@ -67,6 +67,14 @@ const (
 	ReviewStateUnknown models.ReviewStateType = ""
 )
 
+type GiteaLabelGetter interface {
+	GetLabels(org, repo string, idx int64) ([]*models.Label, error)
+}
+
+type GiteaLabelSettter interface {
+	SetLabels(org, repo string, idx int64, labels []string) ([]*models.Label, error)
+}
+
 type GiteaTimelineFetcher interface {
 	GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error)
 }
@@ -86,7 +94,16 @@ type GiteaMaintainershipReader interface {
 
 type GiteaPRFetcher interface {
 	GetPullRequest(org, project string, num int64) (*models.PullRequest, error)
-	GetAssociatedPrjGitPR(prjGitOrg, prjGitRepo, refOrg, refRepo string, Index int64) (*models.PullRequest, error)
+}
+
+type GiteaPRUpdater interface {
+	UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error)
+}
+
+type GiteaPRTimelineReviewFetcher interface {
+	GiteaPRFetcher
+	GiteaTimelineFetcher
+	GiteaReviewFetcher
 }
 
 type GiteaCommitFetcher interface {
@@ -101,16 +118,27 @@ type GiteaCommentFetcher interface {
 	GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error)
 }
 
-type GiteaPRChecker interface {
+type GiteaReviewTimelineFetcher interface {
 	GiteaReviewFetcher
+	GiteaTimelineFetcher
+}
+
+type GiteaPRChecker interface {
+	GiteaReviewTimelineFetcher
 	GiteaCommentFetcher
 	GiteaMaintainershipReader
 }
 
-type GiteaReviewFetcherAndRequester interface {
-	GiteaReviewFetcher
+type GiteaReviewFetcherAndRequesterAndUnrequester interface {
+	GiteaReviewTimelineFetcher
 	GiteaCommentFetcher
 	GiteaReviewRequester
+	GiteaReviewUnrequester
+}
+
+type GiteaUnreviewTimelineFetcher interface {
+	GiteaTimelineFetcher
+	GiteaReviewUnrequester
 }
 
 type GiteaReviewRequester interface {
@@ -148,6 +176,10 @@ type GiteaCommitStatusGetter interface {
 	GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error)
 }
 
+type GiteaMerger interface {
+	ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error
+}
+
 type Gitea interface {
 	GiteaComment
 	GiteaRepoFetcher
@@ -155,6 +187,8 @@ type Gitea interface {
 	GiteaReviewUnrequester
 	GiteaReviewer
 	GiteaPRFetcher
+	GiteaPRUpdater
+	GiteaMerger
 	GiteaCommitFetcher
 	GiteaReviewFetcher
 	GiteaCommentFetcher
@@ -164,18 +198,20 @@ type Gitea interface {
 	GiteaCommitStatusGetter
 	GiteaCommitStatusSetter
 	GiteaSetRepoOptions
+	GiteaLabelGetter
+	GiteaLabelSettter
 
-	GetPullNotifications(since *time.Time) ([]*models.NotificationThread, error)
-	GetDonePullNotifications(page int64) ([]*models.NotificationThread, error)
+	GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error)
+	GetDoneNotifications(Type string, page int64) ([]*models.NotificationThread, error)
 	SetNotificationRead(notificationId int64) error
 	GetOrganization(orgName string) (*models.Organization, error)
 	GetOrganizationRepositories(orgName string) ([]*models.Repository, error)
 	CreateRepositoryIfNotExist(git Git, org, repoName string) (*models.Repository, error)
-	CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error)
-	GetAssociatedPrjGitPR(prjGitOrg, prjGitRepo, refOrg, refRepo string, Index int64) (*models.PullRequest, error)
+	CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error, bool)
 	GetPullRequestFileContent(pr *models.PullRequest, path string) ([]byte, string, error)
 	GetRecentPullRequests(org, repo, branch string) ([]*models.PullRequest, error)
 	GetRecentCommits(org, repo, branch string, commitNo int64) ([]*models.Commit, error)
+	GetPullRequests(org, project string) ([]*models.PullRequest, error)
 
 	GetCurrentUser() (*models.User, error)
 }
@@ -219,9 +255,90 @@ func (gitea *GiteaTransport) GetPullRequest(org, project string, num int64) (*mo
 		gitea.transport.DefaultAuthentication,
 	)
 
+	if err != nil {
+		LogError(err)
+		return nil, err
+	}
+
 	return pr.Payload, err
 }
 
+func (gitea *GiteaTransport) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) {
+	pr, err := gitea.client.Repository.RepoEditPullRequest(
+		repository.NewRepoEditPullRequestParams().
+			WithOwner(org).
+			WithRepo(repo).
+			WithIndex(num).
+			WithBody(options),
+		gitea.transport.DefaultAuthentication,
+	)
+
+	if err != nil {
+		LogError(err)
+		return nil, err
+	}
+
+	return pr.Payload, err
+}
+
+func (gitea *GiteaTransport) ManualMergePR(org, repo string, num int64, commitid string, delBranch bool) error {
+	manual_merge := "manually-merged"
+	_, err := gitea.client.Repository.RepoMergePullRequest(
+		repository.NewRepoMergePullRequestParams().
+			WithOwner(org).
+			WithRepo(repo).
+			WithIndex(num).
+			WithBody(&models.MergePullRequestForm{
+				Do:                     &manual_merge,
+				DeleteBranchAfterMerge: delBranch,
+				HeadCommitID:           commitid,
+			}), gitea.transport.DefaultAuthentication,
+	)
+
+	if err != nil {
+		LogError(err)
+		return err
+	}
+
+	return nil
+}
+
+func (gitea *GiteaTransport) GetPullRequests(org, repo string) ([]*models.PullRequest, error) {
+	var page, limit int64
+
+	prs := make([]*models.PullRequest, 0)
+	limit = 20
+	state := "open"
+
+	for {
+		page++
+		req, err := gitea.client.Repository.RepoListPullRequests(
+			repository.
+				NewRepoListPullRequestsParams().
+				WithDefaults().
+				WithOwner(org).
+				WithRepo(repo).
+				WithState(&state).
+				WithPage(&page).
+				WithLimit(&limit),
+			gitea.transport.DefaultAuthentication)
+
+		if err != nil {
+			return nil, fmt.Errorf("cannot fetch PR list for %s / %s : %w", org, repo, err)
+		}
+
+		if len(req.Payload) == 0 {
+			break
+		}
+		prs = slices.Concat(prs, req.Payload)
+		if len(req.Payload) < int(limit) {
+			break
+		}
+	}
+
+	return prs, nil
+}
+
 func (gitea *GiteaTransport) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) {
 	page := int64(1)
 	limit := int64(10)
@@ -235,11 +352,11 @@ func (gitea *GiteaTransport) GetCommitStatus(org, repo, hash string) ([]*models.
 		if err != nil {
 			return res, err
 		}
-
-		res = append(res, r.Payload...)
-		if len(r.Payload) < int(limit) {
+		if len(r.Payload) == 0 {
 			break
 		}
+		res = append(res, r.Payload...)
+		page++
 	}
 
 	return res, nil
@@ -300,10 +417,10 @@ func (gitea *GiteaTransport) GetPullRequestReviews(org, project string, PRnum in
 			return nil, err
 		}
 
-		allReviews = slices.Concat(allReviews, reviews.Payload)
-		if len(reviews.Payload) < int(limit) {
+		if len(reviews.Payload) == 0 {
 			break
 		}
+		allReviews = slices.Concat(allReviews, reviews.Payload)
 		page++
 	}
 
@@ -367,29 +484,69 @@ func (gitea *GiteaTransport) SetRepoOptions(owner, repo string, manual_merge boo
 	return ok.Payload, err
 }
 
-func (gitea *GiteaTransport) GetPullNotifications(since *time.Time) ([]*models.NotificationThread, error) {
-	bigLimit := int64(100000)
+func (gitea *GiteaTransport) GetLabels(owner, repo string, idx int64) ([]*models.Label, error) {
+	ret, err := gitea.client.Issue.IssueGetLabels(issue.NewIssueGetLabelsParams().WithOwner(owner).WithRepo(repo).WithIndex(idx), gitea.transport.DefaultAuthentication)
+	if err != nil {
+		return nil, err
+	}
+	return ret.Payload, err
+}
 
-	params := notification.NewNotifyGetListParams().
-		WithDefaults().
-		WithSubjectType([]string{"Pull"}).
-		WithStatusTypes([]string{"unread"}).
-		WithLimit(&bigLimit)
-
-	if since != nil {
-		s := strfmt.DateTime(*since)
-		params.SetSince(&s)
+func (gitea *GiteaTransport) SetLabels(owner, repo string, idx int64, labels []string) ([]*models.Label, error) {
+	interfaceLabels := make([]interface{}, len(labels))
+	for i, l := range labels {
+		interfaceLabels[i] = l
 	}
 
-	list, err := gitea.client.Notification.NotifyGetList(params, gitea.transport.DefaultAuthentication)
+	ret, err := gitea.client.Issue.IssueAddLabel(issue.NewIssueAddLabelParams().WithOwner(owner).WithRepo(repo).WithIndex(idx).WithBody(&models.IssueLabelsOption{Labels: interfaceLabels}),
+		gitea.transport.DefaultAuthentication)
+
 	if err != nil {
 		return nil, err
 	}
 
-	return list.Payload, nil
+	return ret.Payload, nil
 }
 
-func (gitea *GiteaTransport) GetDonePullNotifications(page int64) ([]*models.NotificationThread, error) {
+const (
+	GiteaNotificationType_Pull = "Pull"
+)
+
+func (gitea *GiteaTransport) GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error) {
+	bigLimit := int64(20)
+	ret := make([]*models.NotificationThread, 0, 100)
+
+	for page := int64(1); ; page++ {
+		params := notification.NewNotifyGetListParams().
+			WithDefaults().
+			WithSubjectType([]string{Type}).
+			WithStatusTypes([]string{"unread"}).
+			WithLimit(&bigLimit).
+			WithPage(&page)
+
+		if since != nil {
+			s := strfmt.DateTime(*since)
+			params.SetSince(&s)
+		}
+
+		list, err := gitea.client.Notification.NotifyGetList(params, gitea.transport.DefaultAuthentication)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(list.Payload) == 0 {
+			break
+		}
+		ret = slices.Concat(ret, list.Payload)
+		if len(list.Payload) < int(bigLimit) {
+			break
+		}
+	}
+
+	return ret, nil
+}
+
+func (gitea *GiteaTransport) GetDoneNotifications(Type string, page int64) ([]*models.NotificationThread, error) {
 	limit := int64(20)
 	t := true
 
@@ -399,7 +556,7 @@ func (gitea *GiteaTransport) GetDonePullNotifications(page int64) ([]*models.Not
 	list, err := gitea.client.Notification.NotifyGetList(
 		notification.NewNotifyGetListParams().
 			WithAll(&t).
-			WithSubjectType([]string{"Pull"}).
+			WithSubjectType([]string{Type}).
 			WithStatusTypes([]string{"read"}).
 			WithLimit(&limit).
 			WithPage(&page),
@@ -528,19 +685,23 @@ func (gitea *GiteaTransport) CreateRepositoryIfNotExist(git Git, org, repoName s
 	return repo.Payload, nil
 }
 
-func (gitea *GiteaTransport) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error) {
+func (gitea *GiteaTransport) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error, bool) {
 	prOptions := models.CreatePullRequestOption{
-		Base:  repo.DefaultBranch,
+		Base:  targetId,
 		Head:  srcId,
 		Title: title,
 		Body:  body,
 	}
 
 	if pr, err := gitea.client.Repository.RepoGetPullRequestByBaseHead(
-		repository.NewRepoGetPullRequestByBaseHeadParams().WithOwner(repo.Owner.UserName).WithRepo(repo.Name).WithBase(repo.DefaultBranch).WithHead(srcId),
+		repository.NewRepoGetPullRequestByBaseHeadParams().
+			WithOwner(repo.Owner.UserName).
+			WithRepo(repo.Name).
+			WithBase(targetId).
+			WithHead(srcId),
 		gitea.transport.DefaultAuthentication,
-	); err == nil {
-		return pr.Payload, nil
+	); err == nil && pr.Payload.State == "open" {
+		return pr.Payload, nil, false
 	}
 
 	pr, err := gitea.client.Repository.RepoCreatePullRequest(
@@ -554,52 +715,10 @@ func (gitea *GiteaTransport) CreatePullRequestIfNotExist(repo *models.Repository
 	)
 
 	if err != nil {
-		return nil, fmt.Errorf("Cannot create pull request. %w", err)
+		return nil, fmt.Errorf("Cannot create pull request. %w", err), true
 	}
 
-	return pr.GetPayload(), nil
-}
-
-func (gitea *GiteaTransport) GetAssociatedPrjGitPR(prjGitOrg, prjGitRepo, refOrg, refRepo string, Index int64) (*models.PullRequest, error) {
-	var page int64
-	state := "open"
-
-	prLine := fmt.Sprintf(PrPattern, refOrg, refRepo, Index)
-	LogDebug("Finding PrjGitPR for", prLine, " Looking in", prjGitOrg, "/", prjGitRepo)
-	for {
-		page++
-		prs, err := gitea.client.Repository.RepoListPullRequests(
-			repository.
-				NewRepoListPullRequestsParams().
-				WithDefaults().
-				WithOwner(prjGitOrg).
-				WithRepo(prjGitRepo).
-				WithState(&state).
-				WithPage(&page),
-			gitea.transport.DefaultAuthentication)
-
-		if err != nil {
-			return nil, fmt.Errorf("cannot fetch PR list for %s / %s : %w", prjGitOrg, prjGitRepo, err)
-		}
-
-		//      payload_processing:
-		for _, pr := range prs.Payload {
-			lines := strings.Split(pr.Body, "\n")
-
-			for _, line := range lines {
-				if strings.TrimSpace(line) == prLine {
-					LogDebug("Found PR:", pr.Index)
-					return pr, nil
-				}
-			}
-		}
-
-		if len(prs.Payload) < 10 {
-			break
-		}
-	}
-
-	return nil, nil
+	return pr.GetPayload(), nil, true
 }
 
 func (gitea *GiteaTransport) RequestReviews(pr *models.PullRequest, reviewers ...string) ([]*models.PullReview, error) {
@@ -686,39 +805,79 @@ func (gitea *GiteaTransport) AddComment(pr *models.PullRequest, comment string)
 	return nil
 }
 
+type TimelineCacheData struct {
+	data      []*models.TimelineComment
+	lastCheck time.Time
+}
+
+var giteaTimelineCache map[string]TimelineCacheData = make(map[string]TimelineCacheData)
+var giteaTimelineCacheMutex sync.RWMutex
+
+// returns timeline in reverse chronological create order
 func (gitea *GiteaTransport) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
-	limit := int64(20)
 	page := int64(1)
-	resCount := limit
+	resCount := 1
 
-	retData := []*models.TimelineComment{}
+	prID := fmt.Sprintf("%s/%s!%d", org, repo, idx)
+	giteaTimelineCacheMutex.RLock()
+	TimelineCache, IsCached := giteaTimelineCache[prID]
+	var LastCachedTime strfmt.DateTime
+	if IsCached {
+		l := len(TimelineCache.data)
+		if l > 0 {
+			LastCachedTime = TimelineCache.data[0].Updated
+		}
 
-	for resCount == limit {
-		res, err := gitea.client.Issue.IssueGetCommentsAndTimeline(
-			issue.NewIssueGetCommentsAndTimelineParams().
-				WithOwner(org).
-				WithRepo(repo).
-				WithIndex(idx).
-				WithPage(&page).
-				WithLimit(&limit),
-			gitea.transport.DefaultAuthentication,
-		)
+		// cache data for 5 seconds
+		if TimelineCache.lastCheck.Add(time.Second*5).Compare(time.Now()) > 0 {
+			giteaTimelineCacheMutex.RUnlock()
+			return TimelineCache.data, nil
+		}
+	}
+	giteaTimelineCacheMutex.RUnlock()
 
+	giteaTimelineCacheMutex.Lock()
+	defer giteaTimelineCacheMutex.Unlock()
+
+	for resCount > 0 {
+		opts := issue.NewIssueGetCommentsAndTimelineParams().WithOwner(org).WithRepo(repo).WithIndex(idx).WithPage(&page)
+		if !LastCachedTime.IsZero() {
+			opts = opts.WithSince(&LastCachedTime)
+		}
+		res, err := gitea.client.Issue.IssueGetCommentsAndTimeline(opts, gitea.transport.DefaultAuthentication)
 		if err != nil {
 			return nil, err
 		}
 
-		resCount = int64(len(res.Payload))
+		if resCount = len(res.Payload); resCount == 0 {
+			break
+		}
+
+		for _, d := range res.Payload {
+			if d != nil {
+				if time.Time(d.Created).Compare(time.Time(LastCachedTime)) > 0 {
+					// created after last check, so we append here
+					TimelineCache.data = append(TimelineCache.data, d)
+				} else {
+					// we need something updated in the timeline, maybe
+				}
+			}
+		}
+
+		if resCount < 10 {
+			break
+		}
 		page++
-
-		retData = append(retData, res.Payload...)
 	}
-
-	slices.SortFunc(retData, func(a, b *models.TimelineComment) int {
-		return time.Time(a.Created).Compare(time.Time(b.Created))
+	LogDebug("timeline", prID, "# timeline:", len(TimelineCache.data))
+	slices.SortFunc(TimelineCache.data, func(a, b *models.TimelineComment) int {
+		return time.Time(b.Created).Compare(time.Time(a.Created))
 	})
 
-	return retData, nil
+	TimelineCache.lastCheck = time.Now()
+	giteaTimelineCache[prID] = TimelineCache
+
+	return TimelineCache.data, nil
 }
 
 func (gitea *GiteaTransport) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) {

common/listen.go

@@ -1,324 +0,0 @@
-package common
-
-/*
- * This file is part of Autogits.
- *
- * Copyright © 2024 SUSE LLC
- *
- * Autogits is free software: you can redistribute it and/or modify it under
- * the terms of the GNU General Public License as published by the Free Software
- * Foundation, either version 2 of the License, or (at your option) any later
- * version.
- *
- * Autogits is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
- * PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * Foobar. If not, see <https://www.gnu.org/licenses/>.
- */
-
-import (
-	"crypto/tls"
-	"fmt"
-	"net/url"
-	"runtime/debug"
-	"slices"
-	"strings"
-	"time"
-
-	rabbitmq "github.com/rabbitmq/amqp091-go"
-)
-
-const RequestType_CreateBrachTag = "create"
-const RequestType_DeleteBranchTag = "delete"
-const RequestType_Fork = "fork"
-const RequestType_Issue = "issues"
-const RequestType_IssueAssign = "issue_assign"
-const RequestType_IssueComment = "issue_comment"
-const RequestType_IssueLabel = "issue_label"
-const RequestType_IssueMilestone = "issue_milestone"
-const RequestType_Push = "push"
-const RequestType_Repository = "repository"
-const RequestType_Release = "release"
-const RequestType_PR = "pull_request"
-const RequestType_PRAssign = "pull_request_assign"
-const RequestType_PRLabel = "pull_request_label"
-const RequestType_PRComment = "pull_request_comment"
-const RequestType_PRMilestone = "pull_request_milestone"
-const RequestType_PRSync = "pull_request_sync"
-const RequestType_PRReviewAccepted = "pull_request_review_approved"
-const RequestType_PRReviewRejected = "pull_request_review_rejected"
-const RequestType_PRReviewRequest = "pull_request_review_request"
-const RequestType_PRReviewComment = "pull_request_review_comment"
-const RequestType_Wiki = "wiki"
-
-type RequestProcessor interface {
-	ProcessFunc(*Request) error
-}
-
-type ListenDefinitions struct {
-	RabbitURL *url.URL // amqps://user:password@host/queue
-
-	GitAuthor string
-	Handlers  map[string]RequestProcessor
-	Orgs      []string
-
-	topics          []string
-	topicSubChanges chan string // +topic = subscribe, -topic = unsubscribe
-}
-
-type RabbitMessage rabbitmq.Delivery
-
-func (l *ListenDefinitions) processTopicChanges(ch *rabbitmq.Channel, queueName string) {
-	for {
-		topic, ok := <-l.topicSubChanges
-		if !ok {
-			return
-		}
-
-		LogDebug("    topic change:", topic)
-		switch topic[0] {
-		case '+':
-			if err := ch.QueueBind(queueName, topic[1:], "pubsub", false, nil); err != nil {
-				LogError(err)
-			}
-		case '-':
-			if err := ch.QueueUnbind(queueName, topic[1:], "pubsub", nil); err != nil {
-				LogError(err)
-			}
-		default:
-			LogInfo("Ignoring unknown topic change:", topic)
-		}
-	}
-}
-
-func (l *ListenDefinitions) processRabbitMQ(msgCh chan<- RabbitMessage) error {
-	queueName := l.RabbitURL.Path
-	l.RabbitURL.Path = ""
-
-	if len(queueName) > 0 && queueName[0] == '/' {
-		queueName = queueName[1:]
-	}
-
-	connection, err := rabbitmq.DialTLS(l.RabbitURL.String(), &tls.Config{
-		ServerName: l.RabbitURL.Hostname(),
-	})
-	if err != nil {
-		return fmt.Errorf("Cannot connect to %s . Err: %w", l.RabbitURL.Hostname(), err)
-	}
-	defer connection.Close()
-
-	ch, err := connection.Channel()
-	if err != nil {
-		return fmt.Errorf("Cannot create a channel. Err: %w", err)
-	}
-	defer ch.Close()
-
-	if err = ch.ExchangeDeclarePassive("pubsub", "topic", true, false, false, false, nil); err != nil {
-		return fmt.Errorf("Cannot find pubsub exchange? Err: %w", err)
-	}
-
-	var q rabbitmq.Queue
-	if len(queueName) == 0 {
-		q, err = ch.QueueDeclare("", false, true, true, false, nil)
-	} else {
-		q, err = ch.QueueDeclarePassive(queueName, true, false, true, false, nil)
-		if err != nil {
-			LogInfo("queue not found .. trying to create it:", err)
-			if ch.IsClosed() {
-				ch, err = connection.Channel()
-				if err != nil {
-					return fmt.Errorf("Channel cannot be re-opened. Err: %w", err)
-				}
-			}
-			q, err = ch.QueueDeclare(queueName, true, false, true, false, nil)
-
-			if err != nil {
-				LogInfo("can't create persistent queue ... falling back to temporaty queue:", err)
-				if ch.IsClosed() {
-					ch, err = connection.Channel()
-					return fmt.Errorf("Channel cannot be re-opened. Err: %w", err)
-				}
-				q, err = ch.QueueDeclare("", false, true, true, false, nil)
-			}
-		}
-	}
-	if err != nil {
-		return fmt.Errorf("Cannot declare queue. Err: %w", err)
-	}
-	//	log.Printf("queue: %s:%d", q.Name, q.Consumers)
-
-	LogDebug(" -- listening to topics:")
-	l.topicSubChanges = make(chan string)
-	defer close(l.topicSubChanges)
-	go l.processTopicChanges(ch, q.Name)
-
-	for _, topic := range l.topics {
-		l.topicSubChanges <- "+" + topic
-	}
-
-	msgs, err := ch.Consume(q.Name, "", true, true, false, false, nil)
-	if err != nil {
-		return fmt.Errorf("Cannot start consumer. Err: %w", err)
-	}
-	//	log.Printf("queue: %s:%d", q.Name, q.Consumers)
-
-	for {
-		msg, ok := <-msgs
-		if !ok {
-			return fmt.Errorf("channel/connection closed?\n")
-		}
-
-		msgCh <- RabbitMessage(msg)
-	}
-}
-
-func (l *ListenDefinitions) connectAndProcessRabbitMQ(ch chan<- RabbitMessage) {
-	defer func() {
-		if r := recover(); r != nil {
-			LogError(r)
-			LogError("'crash' RabbitMQ worker. Recovering... reconnecting...")
-			time.Sleep(5 * time.Second)
-			go l.connectAndProcessRabbitMQ(ch)
-		}
-	}()
-
-	for {
-		err := l.processRabbitMQ(ch)
-		if err != nil {
-			LogError("Error in RabbitMQ connection. %#v", err)
-			LogInfo("Reconnecting in 2 seconds...")
-			time.Sleep(2 * time.Second)
-		}
-	}
-}
-
-func (l *ListenDefinitions) connectToRabbitMQ() chan RabbitMessage {
-	ch := make(chan RabbitMessage, 100)
-	go l.connectAndProcessRabbitMQ(ch)
-
-	return ch
-}
-
-func ProcessEvent(f RequestProcessor, request *Request) {
-	defer func() {
-		if r := recover(); r != nil {
-			LogError("panic caught")
-			if err, ok := r.(error); !ok {
-				LogError(err)
-			}
-			LogError(string(debug.Stack()))
-		}
-	}()
-
-	if err := f.ProcessFunc(request); err != nil {
-		LogError(err)
-	}
-
-}
-
-func (l *ListenDefinitions) generateTopics() []string {
-	topics := make([]string, 0, len(l.Handlers)*len(l.Orgs))
-	scope := "suse"
-	if l.RabbitURL.Hostname() == "rabbit.opensuse.org" {
-		scope = "opensuse"
-	}
-
-	for _, org := range l.Orgs {
-		for requestType, _ := range l.Handlers {
-			topics = append(topics, fmt.Sprintf("%s.src.%s.%s.#", scope, org, requestType))
-		}
-	}
-
-	slices.Sort(topics)
-	return slices.Compact(topics)
-}
-
-func (l *ListenDefinitions) UpdateTopics() {
-	newTopics := l.generateTopics()
-
-	j := 0
-next_new_topic:
-	for i := 0; i < len(newTopics); i++ {
-		topic := newTopics[i]
-
-		for j < len(l.topics) {
-			cmp := strings.Compare(topic, l.topics[j])
-
-			if cmp == 0 {
-				j++
-				continue next_new_topic
-			}
-
-			if cmp < 0 {
-				l.topicSubChanges <- "+" + topic
-				break
-			}
-
-			l.topicSubChanges <- "-" + l.topics[j]
-			j++
-		}
-
-		if j == len(l.topics) {
-			l.topicSubChanges <- "+" + topic
-		}
-	}
-
-	for j < len(l.topics) {
-		l.topicSubChanges <- "-" + l.topics[j]
-		j++
-	}
-
-	l.topics = newTopics
-}
-
-func (l *ListenDefinitions) ProcessRabbitMQEvents() error {
-	LogInfo("RabbitMQ connection:", l.RabbitURL.String())
-	LogDebug("# Handlers:", len(l.Handlers))
-	LogDebug("# Orgs:", len(l.Orgs))
-
-	l.RabbitURL.User = url.UserPassword(rabbitUser, rabbitPassword)
-	l.topics = l.generateTopics()
-	ch := l.connectToRabbitMQ()
-
-	for {
-		msg, ok := <-ch
-		if !ok {
-			return nil
-		}
-
-		LogDebug("event:", msg.RoutingKey)
-
-		route := strings.Split(msg.RoutingKey, ".")
-		if len(route) > 3 {
-			reqType := route[3]
-			org := route[2]
-
-			if !slices.Contains(l.Orgs, org) {
-				LogInfo("Got event for unhandeled org:", org)
-				continue
-			}
-
-			LogDebug("org:", org, "type:", reqType)
-			if handler, found := l.Handlers[reqType]; found {
-				/*				h, err := CreateRequestHandler()
-								if err != nil {
-									log.Println("Cannot create request handler", err)
-									continue
-								}
-				*/
-				req, err := ParseRequestJSON(reqType, msg.Body)
-				if err != nil {
-					LogError("Error parsing request JSON:", err)
-					continue
-				} else {
-					LogDebug("processing req", req.Type)
-					//					h.Request = req
-					ProcessEvent(handler, req)
-
-				}
-			}
-		}
-	}
-}

common/log.go

@@ -63,6 +63,10 @@ func SetLoggingLevel(ll LogLevel) {
 	logLevel = ll
 }
 
+func GetLoggingLevel() LogLevel {
+	return logLevel
+}
+
 func SetLoggingLevelFromString(ll string) error {
 	switch ll {
 	case "info":

common/maintainership.go

@@ -1,10 +1,12 @@
 package common
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
 	"slices"
+	"strings"
 
 	"src.opensuse.org/autogits/common/gitea-generated/client/repository"
 	"src.opensuse.org/autogits/common/gitea-generated/models"
@@ -13,10 +15,10 @@ import (
 //go:generate mockgen -source=maintainership.go -destination=mock/maintainership.go -typed
 
 type MaintainershipData interface {
-	ListProjectMaintainers() []string
-	ListPackageMaintainers(pkg string) []string
+	ListProjectMaintainers(OptionalGroupExpansion []*ReviewGroup) []string
+	ListPackageMaintainers(Pkg string, OptionalGroupExpasion []*ReviewGroup) []string
 
-	IsApproved(pkg string, reviews []*models.PullReview, submitter string) bool
+	IsApproved(Pkg string, Reviews []*models.PullReview, Submitter string, ReviewGroups []*ReviewGroup) bool
 }
 
 const ProjectKey = ""
@@ -26,11 +28,13 @@ type MaintainershipMap struct {
 	Data         map[string][]string
 	IsDir        bool
 	FetchPackage func(string) ([]byte, error)
+	Raw          []byte
 }
 
-func parseMaintainershipData(data []byte) (*MaintainershipMap, error) {
+func ParseMaintainershipData(data []byte) (*MaintainershipMap, error) {
 	maintainers := &MaintainershipMap{
 		Data: make(map[string][]string),
+		Raw:  data,
 	}
 	if err := json.Unmarshal(data, &maintainers.Data); err != nil {
 		return nil, err
@@ -59,18 +63,18 @@ func FetchProjectMaintainershipData(gitea GiteaMaintainershipReader, org, prjGit
 		}
 	}
 
-	m, err := parseMaintainershipData(data)
+	m, err := ParseMaintainershipData(data)
 	if m != nil {
 		m.IsDir = dir
 		m.FetchPackage = func(pkg string) ([]byte, error) {
-			data , _, err := gitea.FetchMaintainershipDirFile(org, prjGit, branch, pkg)
+			data, _, err := gitea.FetchMaintainershipDirFile(org, prjGit, branch, pkg)
 			return data, err
 		}
 	}
 	return m, err
 }
 
-func (data *MaintainershipMap) ListProjectMaintainers() []string {
+func (data *MaintainershipMap) ListProjectMaintainers(groups []*ReviewGroup) []string {
 	if data == nil {
 		return nil
 	}
@@ -80,6 +84,11 @@ func (data *MaintainershipMap) ListProjectMaintainers() []string {
 		return nil
 	}
 
+	// expands groups
+	for _, g := range groups {
+		m = g.ExpandMaintainers(m)
+	}
+
 	return m
 }
 
@@ -96,7 +105,7 @@ func parsePkgDirData(pkg string, data []byte) []string {
 	return pkgMaintainers
 }
 
-func (data *MaintainershipMap) ListPackageMaintainers(pkg string) []string {
+func (data *MaintainershipMap) ListPackageMaintainers(pkg string, groups []*ReviewGroup) []string {
 	if data == nil {
 		return nil
 	}
@@ -111,7 +120,7 @@ func (data *MaintainershipMap) ListPackageMaintainers(pkg string) []string {
 			}
 		}
 	}
-	prjMaintainers := data.ListProjectMaintainers()
+	prjMaintainers := data.ListProjectMaintainers(nil)
 
 prjMaintainer:
 	for _, prjm := range prjMaintainers {
@@ -123,22 +132,20 @@ prjMaintainer:
 		pkgMaintainers = append(pkgMaintainers, prjm)
 	}
 
+	// expands groups
+	for _, g := range groups {
+		pkgMaintainers = g.ExpandMaintainers(pkgMaintainers)
+	}
+
 	return pkgMaintainers
 }
 
-func (data *MaintainershipMap) IsApproved(pkg string, reviews []*models.PullReview, submitter string) bool {
-	reviewers, found := data.Data[pkg]
-	if !found {
-		if pkg != ProjectKey && data.IsDir {
-			r, err := data.FetchPackage(pkg)
-			if err != nil {
-				return false
-			}
-			reviewers = parsePkgDirData(pkg, r)
-			data.Data[pkg] = reviewers
-		} else {
-			return true
-		}
+func (data *MaintainershipMap) IsApproved(pkg string, reviews []*models.PullReview, submitter string, groups []*ReviewGroup) bool {
+	var reviewers []string
+	if pkg != ProjectKey {
+		reviewers = data.ListPackageMaintainers(pkg, groups)
+	} else {
+		reviewers = data.ListProjectMaintainers(groups)
 	}
 
 	if len(reviewers) == 0 {
@@ -146,11 +153,12 @@ func (data *MaintainershipMap) IsApproved(pkg string, reviews []*models.PullRevi
 	}
 
 	LogDebug("Looking for review by:", reviewers)
+	if slices.Contains(reviewers, submitter) {
+		LogDebug("Submitter is maintainer. Approving.")
+		return true
+	}
+
 	for _, review := range reviews {
-		if slices.Contains(reviewers, submitter) {
-			LogDebug("Submitter is maintainer. Approving.")
-			return true
-		}
 		if !review.Stale && review.State == ReviewStateApproved && slices.Contains(reviewers, review.User.UserName) {
 			LogDebug("Reviewed by", review.User.UserName)
 			return true
@@ -160,13 +168,135 @@ func (data *MaintainershipMap) IsApproved(pkg string, reviews []*models.PullRevi
 	return false
 }
 
+func (data *MaintainershipMap) modifyInplace(writer io.StringWriter) error {
+	var original map[string][]string
+	if err := json.Unmarshal(data.Raw, &original); err != nil {
+		return err
+	}
+
+	dec := json.NewDecoder(bytes.NewReader(data.Raw))
+	_, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	output := ""
+	lastPos := 0
+	modified := false
+
+	type entry struct {
+		key      string
+		valStart int
+		valEnd   int
+	}
+	var entries []entry
+
+	for dec.More() {
+		kToken, _ := dec.Token()
+		key := kToken.(string)
+		var raw json.RawMessage
+		dec.Decode(&raw)
+		valEnd := int(dec.InputOffset())
+		valStart := valEnd - len(raw)
+		entries = append(entries, entry{key, valStart, valEnd})
+	}
+
+	changed := make(map[string]bool)
+	for k, v := range data.Data {
+		if ov, ok := original[k]; !ok || !slices.Equal(v, ov) {
+			changed[k] = true
+		}
+	}
+	for k := range original {
+		if _, ok := data.Data[k]; !ok {
+			changed[k] = true
+		}
+	}
+
+	if len(changed) == 0 {
+		_, err = writer.WriteString(string(data.Raw))
+		return err
+	}
+
+	for _, e := range entries {
+		if v, ok := data.Data[e.key]; ok {
+			prefix := string(data.Raw[lastPos:e.valStart])
+			if modified && strings.TrimSpace(output) == "{" {
+				if commaIdx := strings.Index(prefix, ","); commaIdx != -1 {
+					if quoteIdx := strings.Index(prefix, "\""); quoteIdx == -1 || commaIdx < quoteIdx {
+						prefix = prefix[:commaIdx] + prefix[commaIdx+1:]
+					}
+				}
+			}
+			output += prefix
+			if changed[e.key] {
+				slices.Sort(v)
+				newVal, _ := json.Marshal(v)
+				output += string(newVal)
+				modified = true
+			} else {
+				output += string(data.Raw[e.valStart:e.valEnd])
+			}
+		} else {
+			// Deleted
+			modified = true
+		}
+		lastPos = e.valEnd
+	}
+	output += string(data.Raw[lastPos:])
+
+	// Handle additions (simplistic: at the end)
+	for k, v := range data.Data {
+		if _, ok := original[k]; !ok {
+			slices.Sort(v)
+			newVal, _ := json.Marshal(v)
+			keyStr, _ := json.Marshal(k)
+
+			// Insert before closing brace
+			if idx := strings.LastIndex(output, "}"); idx != -1 {
+				prefix := output[:idx]
+				suffix := output[idx:]
+
+				trimmedPrefix := strings.TrimRight(prefix, " \n\r\t")
+				if !strings.HasSuffix(trimmedPrefix, "{") && !strings.HasSuffix(trimmedPrefix, ",") {
+					// find the actual position of the last non-whitespace character in prefix
+					lastCharIdx := strings.LastIndexAny(prefix, "]}0123456789\"")
+					if lastCharIdx != -1 {
+						prefix = prefix[:lastCharIdx+1] + "," + prefix[lastCharIdx+1:]
+					}
+				}
+
+				insertion := fmt.Sprintf("    %s: %s", string(keyStr), string(newVal))
+				if !strings.HasSuffix(prefix, "\n") {
+					insertion = "\n" + insertion
+				}
+				output = prefix + insertion + "\n" + suffix
+				modified = true
+			}
+		}
+	}
+
+	if modified {
+		_, err := writer.WriteString(output)
+		return err
+	}
+	_, err = writer.WriteString(string(data.Raw))
+	return err
+}
+
 func (data *MaintainershipMap) WriteMaintainershipFile(writer io.StringWriter) error {
 	if data.IsDir {
 		return fmt.Errorf("Not implemented")
 	}
 
-	writer.WriteString("{\n")
+	if len(data.Raw) > 0 {
+		if err := data.modifyInplace(writer); err == nil {
+			return nil
+		}
+	}
 
+	// Fallback to full write
+	writer.WriteString("{\n")
 	if d, ok := data.Data[""]; ok {
 		eol := ","
 		if len(data.Data) == 1 {
@@ -177,20 +307,15 @@ func (data *MaintainershipMap) WriteMaintainershipFile(writer io.StringWriter) e
 		writer.WriteString(fmt.Sprintf("    \"\": %s%s\n", string(str), eol))
 	}
 
-	keys := make([]string, len(data.Data))
-	i := 0
+	keys := make([]string, 0, len(data.Data))
 	for pkg := range data.Data {
 		if pkg == "" {
 			continue
 		}
-		keys[i] = pkg
-		i++
-	}
-	if len(keys) >= i {
-		keys = slices.Delete(keys, i, len(keys))
+		keys = append(keys, pkg)
 	}
 	slices.Sort(keys)
-	for i, pkg := range(keys) {
+	for i, pkg := range keys {
 		eol := ","
 		if i == len(keys)-1 {
 			eol = ""

common/maintainership_test.go

@@ -28,6 +28,8 @@ func TestMaintainership(t *testing.T) {
 		maintainersFile    []byte
 		maintainersFileErr error
 
+		groups []*common.ReviewGroup
+
 		maintainersDir map[string][]byte
 	}{
 		/* PACKAGE MAINTAINERS */
@@ -51,6 +53,22 @@ func TestMaintainership(t *testing.T) {
 			maintainers: []string{"user1", "user2", "user3"},
 			packageName: "pkg",
 		},
+		{
+			name:            "Multiple package maintainers and groups",
+			maintainersFile: []byte(`{"pkg": ["user1", "user2", "g2"],    "": ["g2", "user1", "user3"]}`),
+			maintainersDir: map[string][]byte{
+				"_project": []byte(`{"": ["user1", "user3", "g2"]}`),
+				"pkg":      []byte(`{"pkg": ["user1", "g2", "user2"]}`),
+			},
+			maintainers: []string{"user1", "user2", "user3", "user5"},
+			packageName: "pkg",
+			groups: []*common.ReviewGroup{
+				{
+					Name:      "g2",
+					Reviewers: []string{"user1", "user5"},
+				},
+			},
+		},
 		{
 			name:            "No package maintainers and only project maintainer",
 			maintainersFile: []byte(`{"pkg2": ["user1", "user2"],   "": ["user1", "user3"]}`),
@@ -138,9 +156,9 @@ func TestMaintainership(t *testing.T) {
 
 			var m []string
 			if len(test.packageName) > 0 {
-				m = maintainers.ListPackageMaintainers(test.packageName)
+				m = maintainers.ListPackageMaintainers(test.packageName, test.groups)
 			} else {
-				m = maintainers.ListProjectMaintainers()
+				m = maintainers.ListProjectMaintainers(test.groups)
 			}
 
 			if len(m) != len(test.maintainers) {
@@ -190,6 +208,7 @@ func TestMaintainershipFileWrite(t *testing.T) {
 		name            string
 		is_dir          bool
 		maintainers     map[string][]string
+		raw             []byte
 		expected_output string
 		expected_error  error
 	}{
@@ -207,12 +226,49 @@ func TestMaintainershipFileWrite(t *testing.T) {
 		{
 			name: "2 project maintainers and 2 single package maintainers",
 			maintainers: map[string][]string{
-				"": {"two", "one"},
+				"":     {"two", "one"},
 				"pkg1": {},
 				"foo":  {"four", "byte"},
 			},
 			expected_output: "{\n    \"\": [\"one\",\"two\"],\n    \"foo\": [\"byte\",\"four\"],\n    \"pkg1\": []\n}\n",
 		},
+		{
+			name: "surgical modification",
+			maintainers: map[string][]string{
+				"":     {"one", "two"},
+				"foo":  {"byte", "four", "newone"},
+				"pkg1": {},
+			},
+			raw:             []byte("{\n    \"\": [\"one\",\"two\"],\n    \"foo\": [\"byte\",\"four\"],\n    \"pkg1\": []\n}\n"),
+			expected_output: "{\n    \"\": [\"one\",\"two\"],\n    \"foo\": [\"byte\",\"four\",\"newone\"],\n    \"pkg1\": []\n}\n",
+		},
+		{
+			name: "no change",
+			maintainers: map[string][]string{
+				"":     {"one", "two"},
+				"foo":  {"byte", "four"},
+				"pkg1": {},
+			},
+			raw:             []byte("{\n    \"\": [\"one\",\"two\"],\n    \"foo\": [\"byte\",\"four\"],\n    \"pkg1\": []\n}\n"),
+			expected_output: "{\n    \"\": [\"one\",\"two\"],\n    \"foo\": [\"byte\",\"four\"],\n    \"pkg1\": []\n}\n",
+		},
+		{
+			name: "surgical addition",
+			maintainers: map[string][]string{
+				"":    {"one"},
+				"new": {"user"},
+			},
+			raw:             []byte("{\n    \"\": [  \"one\"  ]\n}\n"),
+			expected_output: "{\n    \"\": [  \"one\"  ],\n    \"new\": [\"user\"]\n}\n",
+		},
+		{
+			name: "surgical deletion",
+			maintainers: map[string][]string{
+				"": {"one"},
+			},
+			raw:             []byte("{\n    \"\": [\"one\"],\n    \"old\": [\"user\"]\n}\n"),
+			expected_output: "{\n    \"\": [\"one\"]\n}\n",
+		},
 	}
 
 	for _, test := range tests {
@@ -221,6 +277,7 @@ func TestMaintainershipFileWrite(t *testing.T) {
 			data := common.MaintainershipMap{
 				Data:  test.maintainers,
 				IsDir: test.is_dir,
+				Raw:   test.raw,
 			}
 
 			if err := data.WriteMaintainershipFile(&b); err != test.expected_error {
@@ -230,7 +287,7 @@ func TestMaintainershipFileWrite(t *testing.T) {
 			output := b.String()
 
 			if test.expected_output != output {
-				t.Fatal("unexpected output:", output, "Expecting:", test.expected_output)
+				t.Fatalf("unexpected output:\n%q\nExpecting:\n%q", output, test.expected_output)
 			}
 		})
 	}

common/manifest.go

@@ -0,0 +1,56 @@
+package common
+
+import (
+	"os"
+	"path"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Manifest struct {
+	Subdirectories []string
+}
+
+func (m *Manifest) SubdirForPackage(pkg string) string {
+	if m == nil {
+		return pkg
+	}
+
+	idx := -1
+	matchLen := 0
+	basePkg := path.Base(pkg)
+	lowercasePkg := strings.ToLower(basePkg)
+
+	for i, sub := range m.Subdirectories {
+		basename := strings.ToLower(path.Base(sub))
+		if strings.HasPrefix(lowercasePkg, basename) && matchLen < len(basename) {
+			idx = i
+			matchLen = len(basename)
+		}
+	}
+
+	if idx > -1 {
+		return path.Join(m.Subdirectories[idx], basePkg)
+	}
+	return pkg
+}
+
+func ReadManifestFile(filename string) (*Manifest, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	return ParseManifestFile(data)
+}
+
+func ParseManifestFile(data []byte) (*Manifest, error) {
+	ret := &Manifest{}
+	err := yaml.Unmarshal(data, ret)
+	if err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}

common/manifest_test.go

@@ -0,0 +1,56 @@
+package common_test
+
+import (
+	"testing"
+
+	"src.opensuse.org/autogits/common"
+)
+
+func TestManifestSubdirAssignments(t *testing.T) {
+	tests := []struct {
+		Name              string
+		ManifestContent   string
+		Packages          []string
+		ManifestLocations []string
+	}{
+		{
+			Name:              "empty manifest",
+			Packages:          []string{"atom", "blarg", "Foobar", "X-Ray", "boost", "NodeJS"},
+			ManifestLocations: []string{"atom", "blarg", "Foobar", "X-Ray", "boost", "NodeJS"},
+		},
+		{
+			Name:              "only few subdirs manifest",
+			ManifestContent:   "subdirectories:\n  - a\n  - b",
+			Packages:          []string{"atom", "blarg", "Foobar", "X-Ray", "Boost", "NodeJS"},
+			ManifestLocations: []string{"a/atom", "b/blarg", "Foobar", "X-Ray", "b/Boost", "NodeJS"},
+		},
+		{
+			Name:              "multilayer subdirs manifest",
+			ManifestContent:   "subdirectories:\n  - a\n  - b\n  - libs/boo",
+			Packages:          []string{"atom", "blarg", "Foobar", "X-Ray", "Boost", "NodeJS"},
+			ManifestLocations: []string{"a/atom", "b/blarg", "Foobar", "X-Ray", "libs/boo/Boost", "NodeJS"},
+		},
+		{
+			Name:              "multilayer subdirs manifest with trailing /",
+			ManifestContent:   "subdirectories:\n  - a\n  - b\n  - libs/boo/\n  - somedir/Node/",
+			Packages:          []string{"atom", "blarg", "Foobar", "X-Ray", "Boost", "NodeJS", "foobar/node2"},
+			ManifestLocations: []string{"a/atom", "b/blarg", "Foobar", "X-Ray", "libs/boo/Boost", "somedir/Node/NodeJS", "somedir/Node/node2"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			m, err := common.ParseManifestFile([]byte(test.ManifestContent))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			for i, pkg := range test.Packages {
+				expected := test.ManifestLocations[i]
+				if l := m.SubdirForPackage(pkg); l != expected {
+					t.Error("Expected:", expected, "but got:", l)
+				}
+			}
+		})
+	}
+}

common/mock/config.go

@@ -0,0 +1,120 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: config.go
+//
+// Generated by this command:
+//
+//	mockgen -source=config.go -destination=mock/config.go -typed
+//
+
+// Package mock_common is a generated GoMock package.
+package mock_common
+
+import (
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+	models "src.opensuse.org/autogits/common/gitea-generated/models"
+)
+
+// MockGiteaFileContentAndRepoFetcher is a mock of GiteaFileContentAndRepoFetcher interface.
+type MockGiteaFileContentAndRepoFetcher struct {
+	ctrl     *gomock.Controller
+	recorder *MockGiteaFileContentAndRepoFetcherMockRecorder
+	isgomock struct{}
+}
+
+// MockGiteaFileContentAndRepoFetcherMockRecorder is the mock recorder for MockGiteaFileContentAndRepoFetcher.
+type MockGiteaFileContentAndRepoFetcherMockRecorder struct {
+	mock *MockGiteaFileContentAndRepoFetcher
+}
+
+// NewMockGiteaFileContentAndRepoFetcher creates a new mock instance.
+func NewMockGiteaFileContentAndRepoFetcher(ctrl *gomock.Controller) *MockGiteaFileContentAndRepoFetcher {
+	mock := &MockGiteaFileContentAndRepoFetcher{ctrl: ctrl}
+	mock.recorder = &MockGiteaFileContentAndRepoFetcherMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockGiteaFileContentAndRepoFetcher) EXPECT() *MockGiteaFileContentAndRepoFetcherMockRecorder {
+	return m.recorder
+}
+
+// GetRepository mocks base method.
+func (m *MockGiteaFileContentAndRepoFetcher) GetRepository(org, repo string) (*models.Repository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRepository", org, repo)
+	ret0, _ := ret[0].(*models.Repository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRepository indicates an expected call of GetRepository.
+func (mr *MockGiteaFileContentAndRepoFetcherMockRecorder) GetRepository(org, repo any) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGiteaFileContentAndRepoFetcher)(nil).GetRepository), org, repo)
+	return &MockGiteaFileContentAndRepoFetcherGetRepositoryCall{Call: call}
+}
+
+// MockGiteaFileContentAndRepoFetcherGetRepositoryCall wrap *gomock.Call
+type MockGiteaFileContentAndRepoFetcherGetRepositoryCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// GetRepositoryFileContent mocks base method.
+func (m *MockGiteaFileContentAndRepoFetcher) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent.
+func (mr *MockGiteaFileContentAndRepoFetcherMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGiteaFileContentAndRepoFetcher)(nil).GetRepositoryFileContent), org, repo, hash, path)
+	return &MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall{Call: call}
+}
+
+// MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall wrap *gomock.Call
+type MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall {
+	c.Call = c.Call.Return(arg0, arg1, arg2)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

common/mock/maintainership.go

@@ -0,0 +1,156 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: maintainership.go
+//
+// Generated by this command:
+//
+//	mockgen -source=maintainership.go -destination=mock/maintainership.go -typed
+//
+
+// Package mock_common is a generated GoMock package.
+package mock_common
+
+import (
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+	common "src.opensuse.org/autogits/common"
+	models "src.opensuse.org/autogits/common/gitea-generated/models"
+)
+
+// MockMaintainershipData is a mock of MaintainershipData interface.
+type MockMaintainershipData struct {
+	ctrl     *gomock.Controller
+	recorder *MockMaintainershipDataMockRecorder
+	isgomock struct{}
+}
+
+// MockMaintainershipDataMockRecorder is the mock recorder for MockMaintainershipData.
+type MockMaintainershipDataMockRecorder struct {
+	mock *MockMaintainershipData
+}
+
+// NewMockMaintainershipData creates a new mock instance.
+func NewMockMaintainershipData(ctrl *gomock.Controller) *MockMaintainershipData {
+	mock := &MockMaintainershipData{ctrl: ctrl}
+	mock.recorder = &MockMaintainershipDataMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockMaintainershipData) EXPECT() *MockMaintainershipDataMockRecorder {
+	return m.recorder
+}
+
+// IsApproved mocks base method.
+func (m *MockMaintainershipData) IsApproved(Pkg string, Reviews []*models.PullReview, Submitter string, ReviewGroups []*common.ReviewGroup) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsApproved", Pkg, Reviews, Submitter, ReviewGroups)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// IsApproved indicates an expected call of IsApproved.
+func (mr *MockMaintainershipDataMockRecorder) IsApproved(Pkg, Reviews, Submitter, ReviewGroups any) *MockMaintainershipDataIsApprovedCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApproved", reflect.TypeOf((*MockMaintainershipData)(nil).IsApproved), Pkg, Reviews, Submitter, ReviewGroups)
+	return &MockMaintainershipDataIsApprovedCall{Call: call}
+}
+
+// MockMaintainershipDataIsApprovedCall wrap *gomock.Call
+type MockMaintainershipDataIsApprovedCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockMaintainershipDataIsApprovedCall) Return(arg0 bool) *MockMaintainershipDataIsApprovedCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockMaintainershipDataIsApprovedCall) Do(f func(string, []*models.PullReview, string, []*common.ReviewGroup) bool) *MockMaintainershipDataIsApprovedCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockMaintainershipDataIsApprovedCall) DoAndReturn(f func(string, []*models.PullReview, string, []*common.ReviewGroup) bool) *MockMaintainershipDataIsApprovedCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ListPackageMaintainers mocks base method.
+func (m *MockMaintainershipData) ListPackageMaintainers(Pkg string, OptionalGroupExpasion []*common.ReviewGroup) []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListPackageMaintainers", Pkg, OptionalGroupExpasion)
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// ListPackageMaintainers indicates an expected call of ListPackageMaintainers.
+func (mr *MockMaintainershipDataMockRecorder) ListPackageMaintainers(Pkg, OptionalGroupExpasion any) *MockMaintainershipDataListPackageMaintainersCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackageMaintainers", reflect.TypeOf((*MockMaintainershipData)(nil).ListPackageMaintainers), Pkg, OptionalGroupExpasion)
+	return &MockMaintainershipDataListPackageMaintainersCall{Call: call}
+}
+
+// MockMaintainershipDataListPackageMaintainersCall wrap *gomock.Call
+type MockMaintainershipDataListPackageMaintainersCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockMaintainershipDataListPackageMaintainersCall) Return(arg0 []string) *MockMaintainershipDataListPackageMaintainersCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockMaintainershipDataListPackageMaintainersCall) Do(f func(string, []*common.ReviewGroup) []string) *MockMaintainershipDataListPackageMaintainersCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockMaintainershipDataListPackageMaintainersCall) DoAndReturn(f func(string, []*common.ReviewGroup) []string) *MockMaintainershipDataListPackageMaintainersCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ListProjectMaintainers mocks base method.
+func (m *MockMaintainershipData) ListProjectMaintainers(OptionalGroupExpansion []*common.ReviewGroup) []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListProjectMaintainers", OptionalGroupExpansion)
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// ListProjectMaintainers indicates an expected call of ListProjectMaintainers.
+func (mr *MockMaintainershipDataMockRecorder) ListProjectMaintainers(OptionalGroupExpansion any) *MockMaintainershipDataListProjectMaintainersCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectMaintainers", reflect.TypeOf((*MockMaintainershipData)(nil).ListProjectMaintainers), OptionalGroupExpansion)
+	return &MockMaintainershipDataListProjectMaintainersCall{Call: call}
+}
+
+// MockMaintainershipDataListProjectMaintainersCall wrap *gomock.Call
+type MockMaintainershipDataListProjectMaintainersCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockMaintainershipDataListProjectMaintainersCall) Return(arg0 []string) *MockMaintainershipDataListProjectMaintainersCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockMaintainershipDataListProjectMaintainersCall) Do(f func([]*common.ReviewGroup) []string) *MockMaintainershipDataListProjectMaintainersCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockMaintainershipDataListProjectMaintainersCall) DoAndReturn(f func([]*common.ReviewGroup) []string) *MockMaintainershipDataListProjectMaintainersCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

common/mock/obs_utils.go

@@ -0,0 +1,85 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: obs_utils.go
+//
+// Generated by this command:
+//
+//	mockgen -source=obs_utils.go -destination=mock/obs_utils.go -typed
+//
+
+// Package mock_common is a generated GoMock package.
+package mock_common
+
+import (
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+	common "src.opensuse.org/autogits/common"
+)
+
+// MockObsStatusFetcherWithState is a mock of ObsStatusFetcherWithState interface.
+type MockObsStatusFetcherWithState struct {
+	ctrl     *gomock.Controller
+	recorder *MockObsStatusFetcherWithStateMockRecorder
+	isgomock struct{}
+}
+
+// MockObsStatusFetcherWithStateMockRecorder is the mock recorder for MockObsStatusFetcherWithState.
+type MockObsStatusFetcherWithStateMockRecorder struct {
+	mock *MockObsStatusFetcherWithState
+}
+
+// NewMockObsStatusFetcherWithState creates a new mock instance.
+func NewMockObsStatusFetcherWithState(ctrl *gomock.Controller) *MockObsStatusFetcherWithState {
+	mock := &MockObsStatusFetcherWithState{ctrl: ctrl}
+	mock.recorder = &MockObsStatusFetcherWithStateMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockObsStatusFetcherWithState) EXPECT() *MockObsStatusFetcherWithStateMockRecorder {
+	return m.recorder
+}
+
+// BuildStatusWithState mocks base method.
+func (m *MockObsStatusFetcherWithState) BuildStatusWithState(project string, opts *common.BuildResultOptions, packages ...string) (*common.BuildResultList, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{project, opts}
+	for _, a := range packages {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "BuildStatusWithState", varargs...)
+	ret0, _ := ret[0].(*common.BuildResultList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BuildStatusWithState indicates an expected call of BuildStatusWithState.
+func (mr *MockObsStatusFetcherWithStateMockRecorder) BuildStatusWithState(project, opts any, packages ...any) *MockObsStatusFetcherWithStateBuildStatusWithStateCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{project, opts}, packages...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildStatusWithState", reflect.TypeOf((*MockObsStatusFetcherWithState)(nil).BuildStatusWithState), varargs...)
+	return &MockObsStatusFetcherWithStateBuildStatusWithStateCall{Call: call}
+}
+
+// MockObsStatusFetcherWithStateBuildStatusWithStateCall wrap *gomock.Call
+type MockObsStatusFetcherWithStateBuildStatusWithStateCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockObsStatusFetcherWithStateBuildStatusWithStateCall) Return(arg0 *common.BuildResultList, arg1 error) *MockObsStatusFetcherWithStateBuildStatusWithStateCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockObsStatusFetcherWithStateBuildStatusWithStateCall) Do(f func(string, *common.BuildResultOptions, ...string) (*common.BuildResultList, error)) *MockObsStatusFetcherWithStateBuildStatusWithStateCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockObsStatusFetcherWithStateBuildStatusWithStateCall) DoAndReturn(f func(string, *common.BuildResultOptions, ...string) (*common.BuildResultList, error)) *MockObsStatusFetcherWithStateBuildStatusWithStateCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

common/obs_utils.go

@@ -127,10 +127,12 @@ type ProjectMeta struct {
 	Groups       []GroupRepoMeta  `xml:"group"`
 	Repositories []RepositoryMeta `xml:"repository"`
 
-	BuildFlags  Flags `xml:"build"`
-	PublicFlags Flags `xml:"publish"`
-	DebugFlags  Flags `xml:"debuginfo"`
-	UseForBuild Flags `xml:"useforbuild"`
+	BuildFlags   Flags `xml:"build"`
+	PublicFlags  Flags `xml:"publish"`
+	DebugFlags   Flags `xml:"debuginfo"`
+	UseForBuild  Flags `xml:"useforbuild"`
+	Access       Flags `xml:"access"`
+	SourceAccess Flags `xml:"sourceaccess"`
 }
 
 type PackageMeta struct {
@@ -140,6 +142,12 @@ type PackageMeta struct {
 	ScmSync string           `xml:"scmsync"`
 	Persons []PersonRepoMeta `xml:"person"`
 	Groups  []GroupRepoMeta  `xml:"group"`
+
+	BuildFlags   Flags `xml:"build"`
+	PublicFlags  Flags `xml:"publish"`
+	DebugFlags   Flags `xml:"debuginfo"`
+	UseForBuild  Flags `xml:"useforbuild"`
+	SourceAccess Flags `xml:"sourceaccess"`
 }
 
 type UserMeta struct {
@@ -156,6 +164,34 @@ type GroupMeta struct {
 	Persons PersonGroup `xml:"person"`
 }
 
+type RequestStateMeta struct {
+	XMLName xml.Name `xml:"state"`
+	State   string   `xml:"name,attr"`
+}
+
+type RequestActionTarget struct {
+	XMLName  xml.Name
+	Project  string  `xml:"project,attr"`
+	Package  string  `xml:"package,attr"`
+	Revision *string `xml:"rev,attr,optional"`
+}
+
+type RequestActionMeta struct {
+	XMLName xml.Name             `xml:"action"`
+	Type    string               `xml:"type,attr"`
+	Source  *RequestActionTarget `xml:"source,optional"`
+	Target  *RequestActionTarget `xml:"target,optional"`
+}
+
+type RequestMeta struct {
+	XMLName xml.Name `xml:"request"`
+	Id      int      `xml:"id,attr"`
+
+	Creator string             `xml:"creator,attr"`
+	Action  *RequestActionMeta `xml:"action"`
+	State   RequestStateMeta   `xml:"state"`
+}
+
 func parseProjectMeta(data []byte) (*ProjectMeta, error) {
 	var meta ProjectMeta
 	err := xml.Unmarshal(data, &meta)
@@ -166,8 +202,83 @@ func parseProjectMeta(data []byte) (*ProjectMeta, error) {
 	return &meta, nil
 }
 
+const (
+	RequestStatus_Unknown    = "unknown"
+	RequestStatus_Accepted   = "accepted"
+	RequestStatus_Superseded = "superseded"
+	RequestStatus_Declined   = "declined"
+	RequestStatus_Revoked    = "revoked"
+	RequestStatus_New        = "new"
+	RequestStatus_Review     = "review"
+)
+
+func (status *RequestStateMeta) IsFinal() bool {
+	switch status.State {
+	case RequestStatus_Declined, RequestStatus_Revoked, RequestStatus_Accepted, RequestStatus_Superseded:
+		return true
+	}
+	return false
+}
+
+func parseRequestXml(data []byte) (*RequestMeta, error) {
+	ret := RequestMeta{}
+	LogDebug("parsing: ", string(data))
+	if err := xml.Unmarshal(data, &ret); err != nil {
+		return nil, err
+	}
+
+	return &ret, nil
+}
+
+func (c *ObsClient) CreateSubmitRequest(sourcePrj, sourcePkg, targetPrj string) (*RequestMeta, error) {
+	url := c.baseUrl.JoinPath("request")
+	query := url.Query()
+	query.Add("cmd", "create")
+	url.RawQuery = query.Encode()
+	request := `<request>
+	<action type="submit">
+		<source project="` + sourcePrj + `" package="` + sourcePkg + `">
+		</source>
+		<target project="` + targetPrj + `" package="` + sourcePkg + `">
+		</target>
+	</action>
+	</request>`
+	res, err := c.ObsRequestRaw("POST", url.String(), strings.NewReader(request))
+
+	if err != nil {
+		return nil, err
+	} else if res.StatusCode != 200 {
+		return nil, fmt.Errorf("Unexpected return code: %d", res.StatusCode)
+	}
+
+	data, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return parseRequestXml(data)
+}
+
+func (c *ObsClient) RequestStatus(requestID int) (*RequestMeta, error) {
+	res, err := c.ObsRequest("GET", []string{"request", fmt.Sprint(requestID)}, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != 200 {
+		return nil, fmt.Errorf("Unexpected return code: %d", res.StatusCode)
+	}
+
+	data, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return parseRequestXml(data)
+}
+
 func (c *ObsClient) GetGroupMeta(gid string) (*GroupMeta, error) {
-	res, err := c.ObsRequest("GET", c.baseUrl.JoinPath("group", gid).String(), nil)
+	res, err := c.ObsRequest("GET", []string{"group", gid}, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -197,7 +308,7 @@ func (c *ObsClient) GetGroupMeta(gid string) (*GroupMeta, error) {
 }
 
 func (c *ObsClient) GetUserMeta(uid string) (*UserMeta, error) {
-	res, err := c.ObsRequest("GET", c.baseUrl.JoinPath("person", uid).String(), nil)
+	res, err := c.ObsRequest("GET", []string{"person", uid}, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -226,7 +337,11 @@ func (c *ObsClient) GetUserMeta(uid string) (*UserMeta, error) {
 	return &meta, nil
 }
 
-func (c *ObsClient) ObsRequest(method string, url string, body io.Reader) (*http.Response, error) {
+func (c *ObsClient) ObsRequest(method string, url_path []string, body io.Reader) (*http.Response, error) {
+	return c.ObsRequestRaw(method, c.baseUrl.JoinPath(url_path...).String(), body)
+}
+
+func (c *ObsClient) ObsRequestRaw(method string, url string, body io.Reader) (*http.Response, error) {
 	req, err := http.NewRequest(method, url, body)
 
 	if err != nil {
@@ -322,7 +437,7 @@ func (c *ObsClient) ObsRequest(method string, url string, body io.Reader) (*http
 }
 
 func (c *ObsClient) GetProjectMeta(project string) (*ProjectMeta, error) {
-	req := c.baseUrl.JoinPath("source", project, "_meta").String()
+	req := []string{"source", project, "_meta"}
 	res, err := c.ObsRequest("GET", req, nil)
 
 	if err != nil {
@@ -348,7 +463,7 @@ func (c *ObsClient) GetProjectMeta(project string) (*ProjectMeta, error) {
 }
 
 func (c *ObsClient) GetPackageMeta(project, pkg string) (*PackageMeta, error) {
-	res, err := c.ObsRequest("GET", c.baseUrl.JoinPath("source", project, pkg, "_meta").String(), nil)
+	res, err := c.ObsRequest("GET", []string{"source", project, pkg, "_meta"}, nil)
 
 	if err != nil {
 		return nil, err
@@ -422,7 +537,7 @@ func (c *ObsClient) SetProjectMeta(meta *ProjectMeta) error {
 		return err
 	}
 
-	res, err := c.ObsRequest("PUT", c.baseUrl.JoinPath("source", meta.Name, "_meta").String(), io.NopCloser(bytes.NewReader(xml)))
+	res, err := c.ObsRequest("PUT", []string{"source", meta.Name, "_meta"}, io.NopCloser(bytes.NewReader(xml)))
 	if err != nil {
 		return err
 	}
@@ -443,7 +558,7 @@ func (c *ObsClient) DeleteProject(project string) error {
 	query := url.Query()
 	query.Add("force", "1")
 	url.RawQuery = query.Encode()
-	res, err := c.ObsRequest("DELETE", url.String(), nil)
+	res, err := c.ObsRequestRaw("DELETE", url.String(), nil)
 
 	if err != nil {
 		return err
@@ -455,25 +570,58 @@ func (c *ObsClient) DeleteProject(project string) error {
 	}
 
 	return nil
+}
 
+func (c *ObsClient) BuildLog(prj, pkg, repo, arch string) (io.ReadCloser, error) {
+	url := c.baseUrl.JoinPath("build", prj, repo, arch, pkg, "_log")
+	query := url.Query()
+	query.Add("nostream", "1")
+	query.Add("start", "0")
+	url.RawQuery = query.Encode()
+	res, err := c.ObsRequestRaw("GET", url.String(), nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Body, nil
 }
 
 type PackageBuildStatus struct {
 	Package string `xml:"package,attr"`
 	Code    string `xml:"code,attr"`
 	Details string `xml:"details"`
+
+	LastUpdate time.Time
+}
+
+func PackageBuildStatusComp(A, B *PackageBuildStatus) int {
+	return strings.Compare(A.Package, B.Package)
 }
 
 type BuildResult struct {
-	Project    string               `xml:"project,attr"`
-	Repository string               `xml:"repository,attr"`
-	Arch       string               `xml:"arch,attr"`
-	Code       string               `xml:"code,attr"`
-	Dirty      bool                 `xml:"dirty,attr"`
-	ScmSync    string               `xml:"scmsync"`
-	ScmInfo    string               `xml:"scminfo"`
-	Status     []PackageBuildStatus `xml:"status"`
-	Binaries   []BinaryList         `xml:"binarylist"`
+	XMLName    xml.Name              `xml:"result" json:"xml,omitempty"`
+	Project    string                `xml:"project,attr"`
+	Repository string                `xml:"repository,attr"`
+	Arch       string                `xml:"arch,attr"`
+	Code       string                `xml:"code,attr"`
+	Dirty      bool                  `xml:"dirty,attr,omitempty"`
+	ScmSync    string                `xml:"scmsync,omitempty"`
+	ScmInfo    string                `xml:"scminfo,omitempty"`
+	Status     []*PackageBuildStatus `xml:"status"`
+	Binaries   []BinaryList          `xml:"binarylist,omitempty"`
+
+	LastUpdate time.Time
+}
+
+func BuildResultComp(A, B *BuildResult) int {
+	if cmp := strings.Compare(A.Project, B.Project); cmp != 0 {
+		return cmp
+	}
+	if cmp := strings.Compare(A.Repository, B.Repository); cmp != 0 {
+		return cmp
+	}
+	return strings.Compare(A.Arch, B.Arch)
 }
 
 type Binary struct {
@@ -488,9 +636,9 @@ type BinaryList struct {
 }
 
 type BuildResultList struct {
-	XMLName xml.Name      `xml:"resultlist"`
-	State   string        `xml:"state,attr"`
-	Result  []BuildResult `xml:"result"`
+	XMLName xml.Name       `xml:"resultlist"`
+	State   string         `xml:"state,attr"`
+	Result  []*BuildResult `xml:"result"`
 
 	isLastBuild bool
 }
@@ -718,9 +866,7 @@ func (obs ObsProjectNotFound) Error() string {
 }
 
 func (c *ObsClient) ProjectConfig(project string) (string, error) {
-	u := c.baseUrl.JoinPath("source", project, "_config")
-
-	res, err := c.ObsRequest("GET", u.String(), nil)
+	res, err := c.ObsRequest("GET", []string{"source", project, "_config"}, nil)
 	if err != nil {
 		return "", err
 	}
@@ -761,7 +907,7 @@ func (c *ObsClient) BuildStatusWithState(project string, opts *BuildResultOption
 		}
 	}
 	u.RawQuery = query.Encode()
-	res, err := c.ObsRequest("GET", u.String(), nil)
+	res, err := c.ObsRequestRaw("GET", u.String(), nil)
 	if err != nil {
 		return nil, err
 	}

common/obs_utils_test.go

@@ -55,6 +55,52 @@ func TestParsingOfBuildResults(t *testing.T) {
 	}
 }
 
+func TestParsingRequestResults(t *testing.T) {
+	res, err := parseRequestXml([]byte(metaRequestData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if res.Id != 42 ||
+		res.Action.Source.Project != "home:foo-user" ||
+		res.Action.Source.Package != "obs-server" ||
+		*res.Action.Source.Revision != "521e" ||
+		res.Action.Target.Project != "OBS:Unstable" ||
+		res.Action.Target.Revision != nil {
+
+		t.Fatal(res)
+	}
+}
+
+const metaRequestData = `<?xml version="1.0" encoding="UTF-8"?>
+<request id="42" creator="foo-user">
+	<action type="submit">
+		<source project="home:foo-user" package="obs-server" rev="521e">
+		</source>
+		<target project="OBS:Unstable" package="obs-server">
+		</target>
+		<options>
+			<sourceupdate>cleanup</sourceupdate>
+		</options>
+	</action>
+	<state name="accepted" who="bar-user" when="2021-01-15T13:39:43">
+		<comment>allright</comment>
+	</state>
+	<review state="accepted" when="2021-01-15T15:49:32" who="obs-maintainer" by_user="obs-maintainer">
+	</review>
+	<review state="accepted" when="2021-01-15T15:49:32" who="obs-maintainer" by_group="obs-group">
+	</review>
+	<review state="accepted" when="2021-01-15T15:49:32" who="obs-maintainer" by_project="OBS:Unstable">
+	</review>
+	<review state="accepted" when="2021-01-15T15:49:32" who="obs-maintainer" by_package="obs-server">
+	</review>
+	<history who="foo" when="2021-01-15T13:39:43">
+		<description>Request created</description>
+		<comment>Please review sources</comment>
+	</history>
+	<description>A little version update</description>
+</request>`
+
 const metaPrjData = `
 <project name="home:adamm">
   <title>Adam's Home Projects</title>

common/pr.go

@@ -9,6 +9,7 @@ import (
 	"slices"
 	"strings"
 
+	"src.opensuse.org/autogits/common/gitea-generated/client/repository"
 	"src.opensuse.org/autogits/common/gitea-generated/models"
 )
 
@@ -22,7 +23,50 @@ type PRSet struct {
 	PRs    []*PRInfo
 	Config *AutogitConfig
 
-	BotUser string
+	BotUser        string
+	HasAutoStaging bool
+}
+
+func (prinfo *PRInfo) PRComponents() (org string, repo string, idx int64) {
+	org = prinfo.PR.Base.Repo.Owner.UserName
+	repo = prinfo.PR.Base.Repo.Name
+	idx = prinfo.PR.Index
+	return
+}
+
+func (prinfo *PRInfo) RemoveReviewers(gitea GiteaUnreviewTimelineFetcher, Reviewers []string, BotUser string) {
+	org, repo, idx := prinfo.PRComponents()
+	tl, err := gitea.GetTimeline(org, repo, idx)
+	if err != nil {
+		LogError("Failed to fetch timeline for", PRtoString(prinfo.PR), err)
+	}
+
+	// find review request for each reviewer
+	ReviewersToUnrequest := Reviewers
+	ReviewersAlreadyChecked := []string{}
+
+	for _, tlc := range tl {
+		if tlc.Type == TimelineCommentType_ReviewRequested && tlc.Assignee != nil {
+			user := tlc.Assignee.UserName
+
+			if idx := slices.Index(ReviewersToUnrequest, user); idx >= 0 && !slices.Contains(ReviewersAlreadyChecked, user) {
+				if tlc.User != nil && tlc.User.UserName == BotUser {
+					ReviewersAlreadyChecked = append(ReviewersAlreadyChecked, user)
+					continue
+				}
+				ReviewersToUnrequest = slices.Delete(ReviewersToUnrequest, idx, idx+1)
+				if len(Reviewers) == 0 {
+					break
+				}
+			}
+		}
+	}
+
+	LogDebug("Unrequesting reviewes for", PRtoString(prinfo.PR), ReviewersToUnrequest)
+	err = gitea.UnrequestReview(org, repo, idx, ReviewersToUnrequest...)
+	if err != nil {
+		LogError("Failed to unrequest reviewers for", PRtoString(prinfo.PR), err)
+	}
 }
 
 func readPRData(gitea GiteaPRFetcher, pr *models.PullRequest, currentSet []*PRInfo, config *AutogitConfig) ([]*PRInfo, error) {
@@ -53,7 +97,66 @@ func readPRData(gitea GiteaPRFetcher, pr *models.PullRequest, currentSet []*PRIn
 	return retSet, nil
 }
 
-func FetchPRSet(user string, gitea GiteaPRFetcher, org, repo string, num int64, config *AutogitConfig) (*PRSet, error) {
+var Timeline_RefIssueNotFound error = errors.New("RefIssue not found on the timeline")
+
+func LastPrjGitRefOnTimeline(botUser string, gitea GiteaPRTimelineReviewFetcher, org, repo string, num int64, config *AutogitConfig) (*models.PullRequest, error) {
+	timeline, err := gitea.GetTimeline(org, repo, num)
+	if err != nil {
+		LogError("Failed to fetch timeline for", org, repo, "#", num, err)
+		return nil, err
+	}
+
+	prjGitOrg, prjGitRepo, prjGitBranch := config.GetPrjGit()
+
+	for idx := len(timeline) - 1; idx >= 0; idx-- {
+		item := timeline[idx]
+		issue := item.RefIssue
+		if item.Type == TimelineCommentType_PullRequestRef &&
+			issue != nil &&
+			issue.Repository != nil &&
+			issue.Repository.Owner == prjGitOrg &&
+			issue.Repository.Name == prjGitRepo {
+
+			if !config.NoProjectGitPR {
+				if issue.User.UserName != botUser {
+					continue
+				}
+			}
+
+			pr, err := gitea.GetPullRequest(prjGitOrg, prjGitRepo, issue.Index)
+			if err != nil {
+				switch err.(type) {
+				case *repository.RepoGetPullRequestNotFound: // deleted?
+					continue
+				default:
+					LogDebug("PrjGit RefIssue fetch error from timeline", issue.Index, err)
+					continue
+				}
+			}
+
+			LogDebug("found ref PR on timeline:", PRtoString(pr))
+			if pr.Base.Name != prjGitBranch {
+				LogDebug(" -> not matching:", pr.Base.Name, prjGitBranch)
+				continue
+			}
+
+			_, prs := ExtractDescriptionAndPRs(bufio.NewScanner(strings.NewReader(item.RefIssue.Body)))
+			for _, pr := range prs {
+				if pr.Org == org && pr.Repo == repo && pr.Num == num {
+					LogDebug("Found PrjGit PR in Timeline:", issue.Index)
+
+					// found prjgit PR in timeline. Return it
+					return gitea.GetPullRequest(prjGitOrg, prjGitRepo, issue.Index)
+				}
+			}
+		}
+	}
+
+	LogDebug("PrjGit RefIssue not found on timeline in", org, repo, num)
+	return nil, Timeline_RefIssueNotFound
+}
+
+func FetchPRSet(user string, gitea GiteaPRTimelineReviewFetcher, org, repo string, num int64, config *AutogitConfig) (*PRSet, error) {
 	var pr *models.PullRequest
 	var err error
 
@@ -63,7 +166,7 @@ func FetchPRSet(user string, gitea GiteaPRFetcher, org, repo string, num int64,
 			return nil, err
 		}
 	} else {
-		if pr, err = gitea.GetAssociatedPrjGitPR(prjGitOrg, prjGitRepo, org, repo, num); err != nil {
+		if pr, err = LastPrjGitRefOnTimeline(user, gitea, org, repo, num, config); err != nil && err != Timeline_RefIssueNotFound {
 			return nil, err
 		}
 
@@ -79,27 +182,69 @@ func FetchPRSet(user string, gitea GiteaPRFetcher, org, repo string, num int64,
 		return nil, err
 	}
 
+	for _, pr := range prs {
+		org, repo, idx := pr.PRComponents()
+		reviews, err := FetchGiteaReviews(gitea, org, repo, idx)
+		if err != nil {
+			LogError("Error fetching reviews for", PRtoString(pr.PR), ":", err)
+		}
+		pr.Reviews = reviews
+	}
+
 	return &PRSet{
-		PRs: prs,
-		Config: config,
+		PRs:     prs,
+		Config:  config,
 		BotUser: user,
 	}, nil
 }
 
-func (rs *PRSet) IsPrjGitPR(pr *models.PullRequest) bool {
-	org, repo, _ := rs.Config.GetPrjGit()
-	return pr.Base.Repo.Name == repo && pr.Base.Repo.Owner.UserName == org
+func (prset *PRSet) RemoveReviewers(gitea GiteaUnreviewTimelineFetcher, reviewers []string) {
+	for _, prinfo := range prset.PRs {
+		prinfo.RemoveReviewers(gitea, reviewers, prset.BotUser)
+	}
 }
 
-func (rs *PRSet) GetPrjGitPR() (*models.PullRequest, error) {
-	var ret *models.PullRequest
+func (rs *PRSet) Find(pr *models.PullRequest) (*PRInfo, bool) {
+	for _, p := range rs.PRs {
+		if p.PR.Base.RepoID == pr.Base.RepoID &&
+			p.PR.Head.Sha == pr.Head.Sha &&
+			p.PR.Base.Name == pr.Base.Name {
+			return p, true
+		}
+	}
+
+	return nil, false
+}
+
+func (rs *PRSet) AddPR(pr *models.PullRequest) *PRInfo {
+	if pr, found := rs.Find(pr); found {
+		return pr
+	}
+
+	prinfo := &PRInfo{
+		PR: pr,
+	}
+	rs.PRs = append(rs.PRs, prinfo)
+	return prinfo
+}
+
+func (rs *PRSet) IsPrjGitPR(pr *models.PullRequest) bool {
+	org, repo, branch := rs.Config.GetPrjGit()
+	return pr.Base.Name == branch && pr.Base.Repo.Name == repo && pr.Base.Repo.Owner.UserName == org
+}
+
+var PRSet_PrjGitMissing error = errors.New("No PrjGit PR found")
+var PRSet_MultiplePrjGit error = errors.New("Multiple PrjGit PRs in one review set")
+
+func (rs *PRSet) GetPrjGitPR() (*PRInfo, error) {
+	var ret *PRInfo
 
 	for _, prinfo := range rs.PRs {
 		if rs.IsPrjGitPR(prinfo.PR) {
 			if ret == nil {
-				ret = prinfo.PR
+				ret = prinfo
 			} else {
-				return nil, errors.New("Multiple PrjGit PRs in one review set")
+				return nil, PRSet_MultiplePrjGit
 			}
 		}
 	}
@@ -108,92 +253,256 @@ func (rs *PRSet) GetPrjGitPR() (*models.PullRequest, error) {
 		return ret, nil
 	}
 
-	return nil, errors.New("No PrjGit PR found")
+	return nil, PRSet_PrjGitMissing
+}
+
+func (rs *PRSet) NeedRecreatingPrjGit(currentBranchHash string) bool {
+	pr, err := rs.GetPrjGitPR()
+	if err != nil {
+		return true
+	}
+
+	return pr.PR.Base.Sha == currentBranchHash
 }
 
 func (rs *PRSet) IsConsistent() bool {
-	prjpr, err := rs.GetPrjGitPR()
+	prjpr_info, err := rs.GetPrjGitPR()
 	if err != nil {
 		return false
 	}
+	prjpr := prjpr_info.PR
+
 	_, prjpr_set := ExtractDescriptionAndPRs(bufio.NewScanner(strings.NewReader(prjpr.Body)))
 	if len(prjpr_set) != len(rs.PRs)-1 { // 1 to many mapping
+		LogDebug("Number of PR from links:", len(prjpr_set), "is not what's expected", len(rs.PRs)-1)
 		return false
 	}
 
 next_rs:
 	for _, prinfo := range rs.PRs {
+		if prinfo.PR.State != "open" {
+			return false
+		}
+
 		if prjpr == prinfo.PR {
 			continue
 		}
 
 		for _, pr := range prjpr_set {
-			if prinfo.PR.Base.Repo.Owner.UserName == pr.Org && prinfo.PR.Base.Repo.Name == pr.Repo && prinfo.PR.Index == pr.Num {
+			if strings.EqualFold(prinfo.PR.Base.Repo.Owner.UserName, pr.Org) && strings.EqualFold(prinfo.PR.Base.Repo.Name, pr.Repo) && prinfo.PR.Index == pr.Num {
 				continue next_rs
 			}
 		}
+		LogDebug("  PR: ", PRtoString(prinfo.PR), "not found in project git PRSet")
 		return false
 	}
 	return true
 }
 
-func (rs *PRSet) AssignReviewers(gitea GiteaReviewFetcherAndRequester, maintainers MaintainershipData) error {
+func (rs *PRSet) FindMissingAndExtraReviewers(maintainers MaintainershipData, idx int) (missing, extra []string) {
 	configReviewers := ParseReviewers(rs.Config.Reviewers)
 
-	for _, pr := range rs.PRs {
-		reviewers := []string{}
-		if rs.IsPrjGitPR(pr.PR) {
-			reviewers = configReviewers.Prj
-			if len(rs.PRs) == 1 {
-				reviewers = slices.Concat(reviewers, maintainers.ListProjectMaintainers())
-			}
+	// remove reviewers that were already requested and are not stale
+	prjMaintainers := maintainers.ListProjectMaintainers(nil)
+	LogDebug("project maintainers:", prjMaintainers)
+
+	pr := rs.PRs[idx]
+	if rs.IsPrjGitPR(pr.PR) {
+		missing = slices.Concat(configReviewers.Prj, configReviewers.PrjOptional)
+		if rs.HasAutoStaging {
+			missing = append(missing, Bot_BuildReview)
+		}
+		LogDebug("PrjGit submitter:", pr.PR.User.UserName)
+		// only need project maintainer reviews if:
+		//    * not created by a bot and has other PRs, or
+		//    * not created by maintainer
+		noReviewPRCreators := prjMaintainers
+		if len(rs.PRs) > 1 {
+			noReviewPRCreators = append(noReviewPRCreators, rs.BotUser)
+		}
+		if slices.Contains(noReviewPRCreators, pr.PR.User.UserName) || pr.Reviews.IsReviewedByOneOf(prjMaintainers...) {
+			LogDebug("Project already reviewed by a project maintainer, remove rest")
+			// do not remove reviewers if they are also maintainers
+			prjMaintainers = slices.DeleteFunc(prjMaintainers, func(m string) bool { return slices.Contains(missing, m) })
+			extra = slices.Concat(prjMaintainers, []string{rs.BotUser})
 		} else {
-			pkg := pr.PR.Base.Repo.Name
-			reviewers = slices.Concat(configReviewers.Pkg, maintainers.ListProjectMaintainers(), maintainers.ListPackageMaintainers(pkg))
-		}
-
-		slices.Sort(reviewers)
-		reviewers = slices.Compact(reviewers)
-
-		// submitters do not need to review their own work
-		if idx := slices.Index(reviewers, pr.PR.User.UserName); idx != -1 {
-			reviewers = slices.Delete(reviewers, idx, idx+1)
-		}
-
-		// remove reviewers that were already requested and are not stale
-		reviews, err := FetchGiteaReviews(gitea, reviewers, pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index)
-		if err != nil {
-			return err
-		}
-
-		for idx := 0; idx < len(reviewers); {
-			user := reviewers[idx]
-			if reviews.HasPendingReviewBy(user) || reviews.IsReviewedBy(user) {
-				reviewers = slices.Delete(reviewers, idx, idx+1)
+			// if bot not created PrjGit or prj maintainer, we need to add project reviewers here
+			if slices.Contains(noReviewPRCreators, pr.PR.User.UserName) {
+				LogDebug("No need for project maintainers")
+				extra = slices.Concat(prjMaintainers, []string{rs.BotUser})
 			} else {
-				idx++
+				LogDebug("Adding prjMaintainers to PrjGit")
+				missing = append(missing, prjMaintainers...)
 			}
 		}
+	} else {
+		pkg := pr.PR.Base.Repo.Name
+		pkgMaintainers := maintainers.ListPackageMaintainers(pkg, nil)
+		Maintainers := slices.Concat(prjMaintainers, pkgMaintainers)
+		noReviewPkgPRCreators := pkgMaintainers
 
-		// get maintainers associated with the PR too
-		if len(reviewers) > 0 {
-			if _, err := gitea.RequestReviews(pr.PR, reviewers...); err != nil {
-				return fmt.Errorf("Cannot create reviews on %s/%s#%d for [%s]: %w", pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index, strings.Join(reviewers, ", "), err)
+		LogDebug("packakge maintainers:", Maintainers)
+
+		missing = slices.Concat(configReviewers.Pkg, configReviewers.PkgOptional)
+		if slices.Contains(noReviewPkgPRCreators, pr.PR.User.UserName) || pr.Reviews.IsReviewedByOneOf(Maintainers...) {
+			// submitter is maintainer or already reviewed
+			LogDebug("Package reviewed by maintainer (or subitter is maintainer), remove the rest of them")
+			// do not remove reviewers if they are also maintainers
+			Maintainers = slices.DeleteFunc(Maintainers, func(m string) bool { return slices.Contains(missing, m) })
+			extra = slices.Concat(Maintainers, []string{rs.BotUser})
+		} else {
+			// maintainer review is missing
+			LogDebug("Adding package maintainers to package git")
+			missing = append(missing, pkgMaintainers...)
+		}
+	}
+
+	slices.Sort(missing)
+	missing = slices.Compact(missing)
+
+	slices.Sort(extra)
+	extra = slices.Compact(extra)
+
+	// submitters cannot review their own work
+	if idx := slices.Index(missing, pr.PR.User.UserName); idx != -1 {
+		missing = slices.Delete(missing, idx, idx+1)
+	}
+
+	LogDebug("PR: ", PRtoString(pr.PR))
+	LogDebug("  preliminary add reviewers for PR:", missing)
+	LogDebug("  preliminary rm  reviewers for PR:", extra)
+
+	// remove missing reviewers that are already done or already pending
+	for idx := 0; idx < len(missing); {
+		user := missing[idx]
+		if pr.Reviews.HasPendingReviewBy(user) || pr.Reviews.IsReviewedBy(user) {
+			missing = slices.Delete(missing, idx, idx+1)
+			LogDebug("   removing done/pending reviewer:", user)
+		} else {
+			idx++
+		}
+	}
+
+	// remove extra reviews that are actually only pending, and only pending by us
+	for idx := 0; idx < len(extra); {
+		user := extra[idx]
+		rr := pr.Reviews.FindReviewRequester(user)
+		if rr != nil && rr.User.UserName == rs.BotUser && pr.Reviews.HasPendingReviewBy(user) {
+			// good to remove this review
+			idx++
+		} else {
+			// this review should not be considered as extra by us
+			LogDebug("   - cannot find? to remove", user)
+			if rr != nil {
+				LogDebug("    ", rr.User.UserName, "vs.", rs.BotUser, pr.Reviews.HasPendingReviewBy(user))
+			}
+			extra = slices.Delete(extra, idx, idx+1)
+		}
+	}
+
+	LogDebug("  add reviewers for PR:", missing)
+	LogDebug("  rm  reviewers for PR:", extra)
+
+	return missing, extra
+}
+
+func (rs *PRSet) AssignReviewers(gitea GiteaReviewFetcherAndRequesterAndUnrequester, maintainers MaintainershipData) error {
+	for idx, pr := range rs.PRs {
+		missingReviewers, extraReviewers := rs.FindMissingAndExtraReviewers(maintainers, idx)
+
+		if len(missingReviewers) > 0 {
+			LogDebug("  Requesting reviews from:", missingReviewers)
+			if !IsDryRun {
+				for _, r := range missingReviewers {
+					if _, err := gitea.RequestReviews(pr.PR, r); err != nil {
+						LogError("Cannot create reviews on", PRtoString(pr.PR), "for user:", r, err)
+					}
+				}
+			}
+		}
+		if len(extraReviewers) > 0 {
+			LogDebug("  UnRequesting reviews from:", extraReviewers)
+			if !IsDryRun {
+				for _, r := range extraReviewers {
+					org, repo, idx := pr.PRComponents()
+					if err := gitea.UnrequestReview(org, repo, idx, r); err != nil {
+						LogError("Cannot unrequest reviews on", PRtoString(pr.PR), "for user:", r, err)
+					}
+				}
 			}
 		}
 	}
 	return nil
 }
 
+func (rs *PRSet) RemoveClosedPRs() {
+	rs.PRs = slices.DeleteFunc(rs.PRs, func(pr *PRInfo) bool {
+		return pr.PR.State != "open"
+	})
+}
+
 func (rs *PRSet) IsApproved(gitea GiteaPRChecker, maintainers MaintainershipData) bool {
 	configReviewers := ParseReviewers(rs.Config.Reviewers)
+	is_manually_reviewed_ok := false
+
+	if need_manual_review := rs.Config.ManualMergeOnly || rs.Config.ManualMergeProject; need_manual_review {
+		// Groups are expanded here because any group member can issue "merge ok" to the BotUser
+		groups := rs.Config.ReviewGroups
+		prjgit, err := rs.GetPrjGitPR()
+		if err == nil && prjgit != nil {
+			reviewers := slices.Concat(configReviewers.Prj, maintainers.ListProjectMaintainers(groups))
+			LogDebug("Fetching reviews for", prjgit.PR.Base.Repo.Owner.UserName, prjgit.PR.Base.Repo.Name, prjgit.PR.Index)
+			r, err := FetchGiteaReviews(gitea, prjgit.PR.Base.Repo.Owner.UserName, prjgit.PR.Base.Repo.Name, prjgit.PR.Index)
+			if err != nil {
+				LogError("Cannot fetch gita reaviews for PR:", err)
+				return false
+			}
+			r.RequestedReviewers = reviewers
+			prjgit.Reviews = r
+			if prjgit.Reviews.IsManualMergeOK() {
+				is_manually_reviewed_ok = true
+			}
+		}
+
+		if !is_manually_reviewed_ok && !rs.Config.ManualMergeProject {
+			for _, pr := range rs.PRs {
+				if rs.IsPrjGitPR(pr.PR) {
+					continue
+				}
+
+				pkg := pr.PR.Base.Repo.Name
+				reviewers := slices.Concat(configReviewers.Pkg, maintainers.ListPackageMaintainers(pkg, groups))
+				LogDebug("Fetching reviews for", pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index)
+				r, err := FetchGiteaReviews(gitea, pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index)
+				if err != nil {
+					LogError("Cannot fetch gita reaviews for PR:", err)
+					return false
+				}
+				r.RequestedReviewers = reviewers
+				pr.Reviews = r
+				if !pr.Reviews.IsManualMergeOK() {
+					LogInfo("Not approved manual merge. PR:", pr.PR.URL)
+					return false
+				}
+			}
+
+			is_manually_reviewed_ok = true
+		}
+
+		if !is_manually_reviewed_ok {
+			LogInfo("manual merge not ok")
+			return false
+		}
+	}
 
-	is_reviewed := false
 	for _, pr := range rs.PRs {
 		var reviewers []string
 		var pkg string
 		if rs.IsPrjGitPR(pr.PR) {
 			reviewers = configReviewers.Prj
+			if rs.HasAutoStaging {
+				reviewers = append(reviewers, Bot_BuildReview)
+			}
 			pkg = ""
 		} else {
 			reviewers = configReviewers.Pkg
@@ -205,19 +514,25 @@ func (rs *PRSet) IsApproved(gitea GiteaPRChecker, maintainers MaintainershipData
 			return false
 		}
 
-		r, err := FetchGiteaReviews(gitea, reviewers, pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index)
+		r, err := FetchGiteaReviews(gitea, pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index)
 		if err != nil {
-			LogError("Cannot fetch gita reaviews for PR:", err)
+			LogError("Cannot fetch gitea reaviews for PR:", err)
 			return false
 		}
-		is_reviewed = r.IsApproved()
-		LogDebug(pr.PR.Base.Repo.Name, is_reviewed)
-		if !is_reviewed {
+		r.RequestedReviewers = reviewers
+
+		is_manually_reviewed_ok = r.IsApproved()
+		LogDebug("PR to", pr.PR.Base.Repo.Name, "reviewed?", is_manually_reviewed_ok)
+		if !is_manually_reviewed_ok {
+			if GetLoggingLevel() > LogLevelInfo {
+				LogDebug("missing reviewers:", r.MissingReviews())
+			}
 			return false
 		}
 
 		if need_maintainer_review := !rs.IsPrjGitPR(pr.PR) || pr.PR.User.UserName != rs.BotUser; need_maintainer_review {
-			if is_reviewed = maintainers.IsApproved(pkg, r.reviews, pr.PR.User.UserName); !is_reviewed {
+			// Do not expand groups here, as the group-review-bot will ACK if group has reviewed.
+			if is_manually_reviewed_ok = maintainers.IsApproved(pkg, r.Reviews, pr.PR.User.UserName, nil); !is_manually_reviewed_ok {
 				LogDebug(" not approved?", pkg)
 				return false
 			}
@@ -225,16 +540,18 @@ func (rs *PRSet) IsApproved(gitea GiteaPRChecker, maintainers MaintainershipData
 			LogDebug("PrjGit PR -- bot created, no need for review")
 		}
 	}
-	return is_reviewed
+	return is_manually_reviewed_ok
 }
 
 func (rs *PRSet) Merge(gitea GiteaReviewUnrequester, git Git) error {
-	prjgit, err := rs.GetPrjGitPR()
+	prjgit_info, err := rs.GetPrjGitPR()
 	if err != nil {
 		return err
 	}
+	prjgit := prjgit_info.PR
 
-	remote, err := git.GitClone(DefaultGitPrj, rs.Config.Branch, prjgit.Base.Repo.SSHURL)
+	_, _, prjgitBranch := rs.Config.GetPrjGit()
+	remote, err := git.GitClone(DefaultGitPrj, prjgitBranch, prjgit.Base.Repo.SSHURL)
 	PanicOnError(err)
 	git.GitExecOrPanic(DefaultGitPrj, "fetch", remote, prjgit.Head.Sha)
 
@@ -251,7 +568,7 @@ func (rs *PRSet) Merge(gitea GiteaReviewUnrequester, git Git) error {
 			panic("FIXME")
 		}
 	*/
-	msg := fmt.Sprintf("Merging\n\nPR: %s/%s#%d", prjgit.Base.Repo.Owner.UserName, prjgit.Base.Repo.Name, prjgit.Index)
+	msg := fmt.Sprintf("Merging\n\nPR: %s/%s!%d", prjgit.Base.Repo.Owner.UserName, prjgit.Base.Repo.Name, prjgit.Index)
 
 	err = git.GitExec(DefaultGitPrj, "merge", "--no-ff", "-m", msg, prjgit.Head.Sha)
 	if err != nil {
@@ -263,6 +580,7 @@ func (rs *PRSet) Merge(gitea GiteaReviewUnrequester, git Git) error {
 		// we can only resolve conflicts with .gitmodules
 		for _, s := range status {
 			if s.Status == GitStatus_Unmerged {
+				panic("Can't handle conflicts yet")
 				if s.Path != ".gitmodules" {
 					return err
 				}
@@ -353,7 +671,15 @@ func (rs *PRSet) Merge(gitea GiteaReviewUnrequester, git Git) error {
 		if rs.IsPrjGitPR(prinfo.PR) {
 			continue
 		}
-		prinfo.RemoteName, err = git.GitClone(repo.Name, rs.Config.Branch, repo.SSHURL)
+		br := rs.Config.Branch
+		if len(br) == 0 {
+			// if branch is unspecified, take it from the PR as it
+			// matches default branch already
+			br = prinfo.PR.Base.Name
+		} else if br != prinfo.PR.Base.Name {
+			panic(prinfo.PR.Base.Name + " is expected to match " + br)
+		}
+		prinfo.RemoteName, err = git.GitClone(repo.Name, br, repo.SSHURL)
 		PanicOnError(err)
 		git.GitExecOrPanic(repo.Name, "fetch", prinfo.RemoteName, head.Sha)
 		git.GitExecOrPanic(repo.Name, "merge", "--ff", head.Sha)

common/rabbitmq.go

@@ -0,0 +1,238 @@
+package common
+
+/*
+ * This file is part of Autogits.
+ *
+ * Copyright © 2024 SUSE LLC
+ *
+ * Autogits is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * Autogits is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * Foobar. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	rabbitmq "github.com/rabbitmq/amqp091-go"
+)
+
+type RabbitConnection struct {
+	RabbitURL *url.URL // amqps://user:password@host/queue
+
+	queueName string
+	ch        *rabbitmq.Channel
+
+	topics          []string
+	topicSubChanges chan string // +topic = subscribe, -topic = unsubscribe
+}
+
+type RabbitProcessor interface {
+	GenerateTopics() []string
+
+	Connection() *RabbitConnection
+	ProcessRabbitMessage(msg RabbitMessage) error
+}
+
+type RabbitMessage rabbitmq.Delivery
+
+func (l *RabbitConnection) ProcessTopicChanges() {
+	for {
+		topic, ok := <-l.topicSubChanges
+		if !ok {
+			return
+		}
+
+		LogDebug("    topic change:", topic)
+		switch topic[0] {
+		case '+':
+			if err := l.ch.QueueBind(l.queueName, topic[1:], "pubsub", false, nil); err != nil {
+				LogError(err)
+			}
+		case '-':
+			if err := l.ch.QueueUnbind(l.queueName, topic[1:], "pubsub", nil); err != nil {
+				LogError(err)
+			}
+		default:
+			LogInfo("Ignoring unknown topic change:", topic)
+		}
+	}
+}
+
+func (l *RabbitConnection) ProcessRabbitMQ(msgCh chan<- RabbitMessage) error {
+	queueName := l.RabbitURL.Path
+	l.RabbitURL.Path = ""
+
+	if len(queueName) > 0 && queueName[0] == '/' {
+		queueName = queueName[1:]
+	}
+
+	connection, err := rabbitmq.DialTLS(l.RabbitURL.String(), &tls.Config{
+		ServerName: l.RabbitURL.Hostname(),
+	})
+	if err != nil {
+		return fmt.Errorf("Cannot connect to %s . Err: %w", l.RabbitURL.Hostname(), err)
+	}
+	defer connection.Close()
+
+	l.ch, err = connection.Channel()
+	if err != nil {
+		return fmt.Errorf("Cannot create a channel. Err: %w", err)
+	}
+	defer l.ch.Close()
+
+	if err = l.ch.ExchangeDeclarePassive("pubsub", "topic", true, false, false, false, nil); err != nil {
+		return fmt.Errorf("Cannot find pubsub exchange? Err: %w", err)
+	}
+
+	var q rabbitmq.Queue
+	if len(queueName) == 0 {
+		q, err = l.ch.QueueDeclare("", false, true, true, false, nil)
+	} else {
+		q, err = l.ch.QueueDeclarePassive(queueName, true, false, true, false, nil)
+		if err != nil {
+			LogInfo("queue not found .. trying to create it:", err)
+			if l.ch.IsClosed() {
+				l.ch, err = connection.Channel()
+				if err != nil {
+					return fmt.Errorf("Channel cannot be re-opened. Err: %w", err)
+				}
+			}
+			q, err = l.ch.QueueDeclare(queueName, true, false, true, false, nil)
+
+			if err != nil {
+				LogInfo("can't create persistent queue ... falling back to temporaty queue:", err)
+				if l.ch.IsClosed() {
+					l.ch, err = connection.Channel()
+					return fmt.Errorf("Channel cannot be re-opened. Err: %w", err)
+				}
+				q, err = l.ch.QueueDeclare("", false, true, true, false, nil)
+			}
+		}
+	}
+	if err != nil {
+		return fmt.Errorf("Cannot declare queue. Err: %w", err)
+	}
+	//	log.Printf("queue: %s:%d", q.Name, q.Consumers)
+
+	LogDebug(" -- listening to topics:")
+	l.topicSubChanges = make(chan string)
+	defer close(l.topicSubChanges)
+	go l.ProcessTopicChanges()
+
+	for _, topic := range l.topics {
+		l.topicSubChanges <- "+" + topic
+	}
+
+	msgs, err := l.ch.Consume(q.Name, "", true, true, false, false, nil)
+	if err != nil {
+		return fmt.Errorf("Cannot start consumer. Err: %w", err)
+	}
+	//	log.Printf("queue: %s:%d", q.Name, q.Consumers)
+
+	for {
+		msg, ok := <-msgs
+		if !ok {
+			return fmt.Errorf("channel/connection closed?\n")
+		}
+
+		msgCh <- RabbitMessage(msg)
+	}
+}
+
+func (l *RabbitConnection) ConnectAndProcessRabbitMQ(ch chan<- RabbitMessage) {
+	defer func() {
+		if r := recover(); r != nil {
+			LogError(r)
+			LogError("'crash' RabbitMQ worker. Recovering... reconnecting...")
+			time.Sleep(5 * time.Second)
+			go l.ConnectAndProcessRabbitMQ(ch)
+		}
+	}()
+
+	for {
+		err := l.ProcessRabbitMQ(ch)
+		if err != nil {
+			LogError("Error in RabbitMQ connection:", err)
+			LogInfo("Reconnecting in 2 seconds...")
+			time.Sleep(2 * time.Second)
+		}
+	}
+}
+
+func (l *RabbitConnection) ConnectToRabbitMQ(processor RabbitProcessor) <-chan RabbitMessage {
+	LogInfo("RabbitMQ connection:", l.RabbitURL.String())
+
+	l.RabbitURL.User = url.UserPassword(rabbitUser, rabbitPassword)
+	l.topics = processor.GenerateTopics()
+
+	ch := make(chan RabbitMessage, 100)
+	go l.ConnectAndProcessRabbitMQ(ch)
+
+	return ch
+}
+
+func (l *RabbitConnection) UpdateTopics(processor RabbitProcessor) {
+	newTopics := processor.GenerateTopics()
+
+	j := 0
+next_new_topic:
+	for i := 0; i < len(newTopics); i++ {
+		topic := newTopics[i]
+
+		for j < len(l.topics) {
+			cmp := strings.Compare(topic, l.topics[j])
+
+			if cmp == 0 {
+				j++
+				continue next_new_topic
+			}
+
+			if cmp < 0 {
+				l.topicSubChanges <- "+" + topic
+				break
+			}
+
+			l.topicSubChanges <- "-" + l.topics[j]
+			j++
+		}
+
+		if j == len(l.topics) {
+			l.topicSubChanges <- "+" + topic
+		}
+	}
+
+	for j < len(l.topics) {
+		l.topicSubChanges <- "-" + l.topics[j]
+		j++
+	}
+
+	l.topics = newTopics
+}
+
+func ProcessRabbitMQEvents(processor RabbitProcessor) error {
+	ch := processor.Connection().ConnectToRabbitMQ(processor)
+
+	for {
+		msg, ok := <-ch
+		if !ok {
+			return nil
+		}
+
+		LogDebug("event:", msg.RoutingKey)
+		if err := processor.ProcessRabbitMessage(msg); err != nil {
+			LogError("Error processing", msg.RoutingKey, err)
+		}
+	}
+}

common/rabbitmq_gitea.go

@@ -0,0 +1,129 @@
+package common
+
+/*
+ * This file is part of Autogits.
+ *
+ * Copyright © 2024 SUSE LLC
+ *
+ * Autogits is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * Autogits is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * Foobar. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import (
+	"fmt"
+	"runtime/debug"
+	"slices"
+	"strings"
+)
+
+const RequestType_CreateBrachTag = "create"
+const RequestType_DeleteBranchTag = "delete"
+const RequestType_Fork = "fork"
+const RequestType_Issue = "issues"
+const RequestType_IssueAssign = "issue_assign"
+const RequestType_IssueComment = "issue_comment"
+const RequestType_IssueLabel = "issue_label"
+const RequestType_IssueMilestone = "issue_milestone"
+const RequestType_Push = "push"
+const RequestType_Repository = "repository"
+const RequestType_Release = "release"
+const RequestType_PR = "pull_request"
+const RequestType_PRAssign = "pull_request_assign"
+const RequestType_PRLabel = "pull_request_label"
+const RequestType_PRComment = "pull_request_comment"
+const RequestType_PRMilestone = "pull_request_milestone"
+const RequestType_PRSync = "pull_request_sync"
+const RequestType_PRReviewAccepted = "pull_request_review_approved"
+const RequestType_PRReviewRejected = "pull_request_review_rejected"
+const RequestType_PRReviewRequest = "pull_request_review_request"
+const RequestType_PRReviewComment = "pull_request_review_comment"
+const RequestType_Status = "status"
+const RequestType_Wiki = "wiki"
+
+type RequestProcessor interface {
+	ProcessFunc(*Request) error
+}
+
+type RabbitMQGiteaEventsProcessor struct {
+	Handlers map[string]RequestProcessor
+	Orgs     []string
+
+	c *RabbitConnection
+}
+
+func (gitea *RabbitMQGiteaEventsProcessor) Connection() *RabbitConnection {
+	if gitea.c == nil {
+		gitea.c = &RabbitConnection{}
+	}
+	return gitea.c
+}
+
+func (gitea *RabbitMQGiteaEventsProcessor) GenerateTopics() []string {
+	topics := make([]string, 0, len(gitea.Handlers)*len(gitea.Orgs))
+	scope := "suse"
+	if gitea.c.RabbitURL.Hostname() == "rabbit.opensuse.org" {
+		scope = "opensuse"
+	}
+
+	for _, org := range gitea.Orgs {
+		for requestType, _ := range gitea.Handlers {
+			topics = append(topics, fmt.Sprintf("%s.src.%s.%s.#", scope, org, requestType))
+		}
+	}
+
+	slices.Sort(topics)
+	return slices.Compact(topics)
+}
+
+func (gitea *RabbitMQGiteaEventsProcessor) ProcessRabbitMessage(msg RabbitMessage) error {
+	route := strings.Split(msg.RoutingKey, ".")
+	if len(route) > 3 {
+		reqType := route[3]
+		org := route[2]
+
+		if !slices.Contains(gitea.Orgs, org) {
+			LogInfo("Got event for unhandeled org:", org)
+			return nil
+		}
+
+		LogDebug("org:", org, "type:", reqType)
+		if handler, found := gitea.Handlers[reqType]; found {
+			req, err := ParseRequestJSON(reqType, msg.Body)
+			if err != nil {
+				LogError("Error parsing request JSON:", err)
+			} else {
+				LogDebug("processing req", req.Type)
+				//					h.Request = req
+				ProcessEvent(handler, req)
+			}
+			return nil
+		}
+	}
+
+	return fmt.Errorf("Invalid routing key: %s", route)
+}
+
+func ProcessEvent(f RequestProcessor, request *Request) {
+	defer func() {
+		if r := recover(); r != nil {
+			LogError("panic caught")
+			if err, ok := r.(error); !ok {
+				LogError(err)
+			}
+			LogError(string(debug.Stack()))
+		}
+	}()
+
+	if err := f.ProcessFunc(request); err != nil {
+		LogError(err)
+	}
+}

common/rabbitmq_obs.go

@@ -0,0 +1,22 @@
+package common
+
+type RabbitMQObsBuildStatusProcessor struct {
+	c *RabbitConnection
+}
+
+func (o *RabbitMQObsBuildStatusProcessor) GenerateTopics() []string {
+return []string{}
+}
+
+func (o *RabbitMQObsBuildStatusProcessor) Connection() *RabbitConnection {
+	if o.c == nil {
+		o.c = &RabbitConnection{}
+	}
+
+	return o.c
+}
+
+func (o *RabbitMQObsBuildStatusProcessor) ProcessRabbitMessage(msg RabbitMessage) error {
+return nil
+}
+

common/rabbitmq_test.go

@@ -50,11 +50,13 @@ func TestListenDefinitionsTopicUpdate(t *testing.T) {
 	u, _ := url.Parse("amqps://rabbit.example.com")
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			l := ListenDefinitions{
-				Orgs:            test.orgs1,
-				Handlers:        make(map[string]RequestProcessor),
-				topicSubChanges: make(chan string, len(test.topicDelta)*10),
-				RabbitURL:       u,
+			l := &RabbitMQGiteaEventsProcessor{
+				Orgs:     test.orgs1,
+				Handlers: make(map[string]RequestProcessor),
+				c: &RabbitConnection{
+					RabbitURL:       u,
+					topicSubChanges: make(chan string, len(test.topicDelta)*10),
+				},
 			}
 
 			slices.Sort(test.topicDelta)
@@ -64,11 +66,11 @@ func TestListenDefinitionsTopicUpdate(t *testing.T) {
 			}
 
 			changes := []string{}
-			l.UpdateTopics()
+			l.c.UpdateTopics(l)
 		a:
 			for {
 				select {
-				case c := <-l.topicSubChanges:
+				case c := <-l.c.topicSubChanges:
 					changes = append(changes, c)
 				default:
 					changes = []string{}
@@ -78,13 +80,13 @@ func TestListenDefinitionsTopicUpdate(t *testing.T) {
 
 			l.Orgs = test.orgs2
 
-			l.UpdateTopics()
+			l.c.UpdateTopics(l)
 			changes = []string{}
 
 		b:
 			for {
 				select {
-				case c := <-l.topicSubChanges:
+				case c := <-l.c.topicSubChanges:
 					changes = append(changes, c)
 				default:
 					slices.Sort(changes)

common/request_status.go

@@ -0,0 +1,62 @@
+package common
+
+/*
+ * This file is part of Autogits.
+ *
+ * Copyright © 2024 SUSE LLC
+ *
+ * Autogits is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * Autogits is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * Foobar. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+type Status struct {
+}
+
+type StatusWebhookEvent struct {
+	Id          uint64
+	Context     string
+	Description string
+	Sha         string
+	State       string
+	TargetUrl   string
+
+	Commit     Commit
+	Repository Repository
+	Sender     *User
+}
+
+func (s *StatusWebhookEvent) GetAction() string {
+	return s.State
+}
+
+func (h *RequestHandler) ParseStatusRequest(data io.Reader) (*StatusWebhookEvent, error) {
+	action := new(StatusWebhookEvent)
+	err := json.NewDecoder(data).Decode(&action)
+
+	if err != nil {
+		return nil, fmt.Errorf("Got error while parsing: %w", err)
+	}
+
+	h.StdLogger.Printf("Request status for repo: %s#%s\n", action.Repository.Full_Name, action.Sha)
+	h.Request = &Request{
+		Type: RequestType_Status,
+		Data: action,
+	}
+
+	return action, nil
+}

common/request_status_test.go

@@ -0,0 +1,40 @@
+package common_test
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"src.opensuse.org/autogits/common"
+)
+
+func TestStatusRequestParsing(t *testing.T) {
+	t.Run("parsing repo creation message", func(t *testing.T) {
+		var h common.RequestHandler
+
+		h.StdLogger, h.ErrLogger = common.CreateStdoutLogger(os.Stdout, os.Stdout)
+		json, err := h.ParseStatusRequest(strings.NewReader(requestStatusJSON))
+		if err != nil {
+			t.Fatalf("Can't parse struct: %s", err)
+		}
+
+		if json.GetAction() != "pending" {
+			t.Fatalf("json.action is '%#v'", json)
+		}
+
+		if json.Repository.Full_Name != "autogits/nodejs-common" ||
+			json.Repository.Parent == nil ||
+			json.Repository.Parent.Parent != nil ||
+			len(json.Repository.Ssh_Url) < 10 ||
+			json.Repository.Default_Branch != "factory" ||
+			json.Repository.Object_Format_Name != "sha256" {
+
+			t.Fatalf("invalid repository parse: %#v", json.Repository)
+		}
+
+		if json.Sha != "e637d86cbbdd438edbf60148e28f9d75a74d51b27b01f75610f247cd18394c8e" {
+			t.Fatal("Invalid SHA:", json.Sha)
+		}
+	})
+}
+

common/review_group.go

@@ -0,0 +1,17 @@
+package common
+
+import (
+	"slices"
+)
+
+func (group *ReviewGroup) ExpandMaintainers(maintainers []string) []string {
+	idx := slices.Index(maintainers, group.Name)
+	if idx == -1 {
+		return maintainers
+	}
+
+	expandedMaintainers := slices.Replace(maintainers, idx, idx+1, group.Reviewers...)
+	slices.Sort(expandedMaintainers)
+	return slices.Compact(expandedMaintainers)
+}
+

common/review_group_test.go

@@ -0,0 +1,62 @@
+package common_test
+
+import (
+	"slices"
+	"testing"
+
+	"src.opensuse.org/autogits/common"
+)
+
+func TestMaintainerGroupReplacer(t *testing.T) {
+	GroupName := "my_group"
+
+	tests := []struct {
+		name          string
+		reviewers     []string
+		group_members []string
+
+		output []string
+	}{
+		{
+			name: "empty",
+		},
+		{
+			name:          "group not maintainer",
+			reviewers:     []string{"a", "b"},
+			group_members: []string{"g1", "g2"},
+			output:        []string{"a", "b"},
+		},
+		{
+			name:          "group maintainer",
+			reviewers:     []string{"b", "my_group"},
+			group_members: []string{"g1", "g2"},
+			output:        []string{"b", "g1", "g2"},
+		},
+		{
+			name:          "sorted group maintainer",
+			reviewers:     []string{"my_group", "b"},
+			group_members: []string{"g1", "g2"},
+			output:        []string{"b", "g1", "g2"},
+		},
+		{
+			name:          "group maintainer dedup",
+			reviewers:     []string{"my_group", "g2", "b"},
+			group_members: []string{"g1", "g2"},
+			output:        []string{"b", "g1", "g2"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			g := &common.ReviewGroup{
+				Name:      GroupName,
+				Reviewers: test.group_members,
+			}
+
+			expandedList := g.ExpandMaintainers(test.reviewers)
+			if slices.Compare(expandedList, test.output) != 0 {
+				t.Error("Expected:", test.output, "but have", expandedList)
+			}
+		})
+	}
+}

common/reviewers.go

@@ -1,33 +1,36 @@
 package common
 
-import (
-	"slices"
-)
-
 type Reviewers struct {
 	Prj []string
 	Pkg []string
+
+	PrjOptional []string
+	PkgOptional []string
 }
 
 func ParseReviewers(input []string) *Reviewers {
 	r := &Reviewers{}
 	for _, reviewer := range input {
+		pkg := &r.Pkg
+		prj := &r.Prj
+
+		if reviewer[0] == '~' {
+			pkg = &r.PkgOptional
+			prj = &r.PrjOptional
+			reviewer = reviewer[1:]
+		}
+
 		switch reviewer[0] {
 		case '*':
-			r.Prj = append(r.Prj, reviewer[1:])
-			r.Pkg = append(r.Pkg, reviewer[1:])
+			*prj = append(*prj, reviewer[1:])
+			*pkg = append(*pkg, reviewer[1:])
 		case '-':
-			r.Prj = append(r.Prj, reviewer[1:])
+			*prj = append(*prj, reviewer[1:])
 		case '+':
-			r.Pkg = append(r.Pkg, reviewer[1:])
+			*pkg = append(*pkg, reviewer[1:])
 		default:
-			r.Pkg = append(r.Pkg, reviewer)
+			*pkg = append(*pkg, reviewer)
 		}
 	}
-
-	if !slices.Contains(r.Prj, Bot_BuildReview) {
-		r.Prj = append(r.Prj, Bot_BuildReview)
-	}
-
 	return r
 }

common/reviewers_test.go

@@ -12,16 +12,27 @@ func TestReviewers(t *testing.T) {
 		name  string
 		input []string
 
-		prj []string
-		pkg []string
+		prj          []string
+		pkg          []string
+		pkg_optional []string
+		prj_optional []string
 	}{
 		{
 			name:  "project and package reviewers",
 			input: []string{"1", "2", "3", "*5", "+6", "-7"},
 
-			prj: []string{"5", "7", common.Bot_BuildReview},
+			prj: []string{"5", "7"},
 			pkg: []string{"1", "2", "3", "5", "6"},
 		},
+		{
+			name:  "optional project and package reviewers",
+			input: []string{"~1", "2", "3", "~*5", "+6", "-7"},
+
+			prj:          []string{"7"},
+			pkg:          []string{"2", "3", "6"},
+			prj_optional: []string{"5"},
+			pkg_optional: []string{"1", "5"},
+		},
 	}
 
 	for _, test := range tests {
@@ -31,7 +42,13 @@ func TestReviewers(t *testing.T) {
 				t.Error("unexpected return of ForProject():", reviewers.Prj)
 			}
 			if !slices.Equal(reviewers.Pkg, test.pkg) {
-				t.Error("unexpected return of ForProject():", reviewers.Pkg)
+				t.Error("unexpected return of ForPackage():", reviewers.Pkg)
+			}
+			if !slices.Equal(reviewers.PrjOptional, test.prj_optional) {
+				t.Error("unexpected return of ForProjectOptional():", reviewers.Prj)
+			}
+			if !slices.Equal(reviewers.PkgOptional, test.pkg_optional) {
+				t.Error("unexpected return of ForPackageOptional():", reviewers.Pkg)
 			}
 		})
 	}

common/reviews.go

@@ -1,36 +1,141 @@
 package common
 
 import (
+	"regexp"
 	"slices"
+	"strings"
 
 	"src.opensuse.org/autogits/common/gitea-generated/models"
 )
 
 type PRReviews struct {
-	reviews   []*models.PullReview
-	reviewers []string
+	Reviews            []*models.PullReview
+	RequestedReviewers []string
+	Comments           []*models.TimelineComment
+
+	FullTimeline []*models.TimelineComment
 }
 
-func FetchGiteaReviews(rf GiteaReviewFetcher, reviewers []string, org, repo string, no int64) (*PRReviews, error) {
-	reviews, err := rf.GetPullRequestReviews(org, repo, no)
+func FetchGiteaReviews(rf GiteaReviewTimelineFetcher, org, repo string, no int64) (*PRReviews, error) {
+	timeline, err := rf.GetTimeline(org, repo, no)
 	if err != nil {
 		return nil, err
 	}
 
+	rawReviews, err := rf.GetPullRequestReviews(org, repo, no)
+	if err != nil {
+		return nil, err
+	}
+
+	reviews := make([]*models.PullReview, 0, 10)
+	needNewReviews := []string{}
+	var comments []*models.TimelineComment
+
+	alreadyHaveUserReview := func(user string) bool {
+		if slices.Contains(needNewReviews, user) {
+			return true
+		}
+		for _, r := range reviews {
+			if r.User != nil && r.User.UserName == user {
+				return true
+			}
+		}
+		return false
+	}
+
+	LogDebug("FetchingGiteaReviews for", org, repo, no)
+	LogDebug("Number of reviews:", len(rawReviews))
+	LogDebug("Number of items in timeline:", len(timeline))
+
+	cutOffIdx := len(timeline)
+	for idx, item := range timeline {
+		if item.Type == TimelineCommentType_Review || item.Type == TimelineCommentType_ReviewRequested {
+			for _, r := range rawReviews {
+				if r.ID == item.ReviewID {
+					if !alreadyHaveUserReview(r.User.UserName) {
+						if item.Type == TimelineCommentType_Review && idx > cutOffIdx {
+							needNewReviews = append(needNewReviews, r.User.UserName)
+						} else {
+							reviews = append(reviews, r)
+						}
+					}
+					break
+				}
+			}
+		} else if item.Type == TimelineCommentType_Comment && cutOffIdx > idx {
+			comments = append(comments, item)
+		} else if item.Type == TimelineCommentType_PushPull && cutOffIdx == len(timeline) {
+			LogDebug("cut-off", item.Created, "@", idx)
+			cutOffIdx = idx
+		} else {
+			LogDebug("Unhandled timeline type:", item.Type)
+		}
+	}
+	LogDebug("num comments:", len(comments), "timeline:", len(reviews))
+
 	return &PRReviews{
-		reviews:   reviews,
-		reviewers: reviewers,
+		Reviews:      reviews,
+		Comments:     comments,
+		FullTimeline: timeline,
 	}, nil
 }
 
+const ManualMergeOK = "^merge\\s+ok(\\W|$)"
+
+var merge_ok_regex *regexp.Regexp = regexp.MustCompile(ManualMergeOK)
+
+func bodyCommandManualMergeOK(body string) bool {
+	lines := SplitLines(body)
+	for _, line := range lines {
+		if merge_ok_regex.MatchString(strings.ToLower(line)) {
+			return true
+		}
+	}
+	return false
+}
+
+func (r *PRReviews) IsManualMergeOK() bool {
+	if r == nil {
+		return false
+	}
+
+	for _, c := range r.Comments {
+		if c.Updated != c.Created {
+			continue
+		}
+		LogDebug("comment:", c.User.UserName, c.Body)
+		if slices.Contains(r.RequestedReviewers, c.User.UserName) {
+			if bodyCommandManualMergeOK(c.Body) {
+				return true
+			}
+		}
+	}
+
+	for _, c := range r.Reviews {
+		if c.Updated != c.Submitted {
+			continue
+		}
+		if slices.Contains(r.RequestedReviewers, c.User.UserName) {
+			if bodyCommandManualMergeOK(c.Body) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 func (r *PRReviews) IsApproved() bool {
+	if r == nil {
+		return false
+	}
 	goodReview := true
 
-	LogDebug("reviewers:", r.reviewers)
-	for _, reviewer := range r.reviewers {
+	for _, reviewer := range r.RequestedReviewers {
 		goodReview = false
-		for _, review := range r.reviews {
+		for _, review := range r.Reviews {
 			if review.User.UserName == reviewer && review.State == ReviewStateApproved && !review.Stale && !review.Dismissed {
+				LogDebug("  -- found review: ", review.User.UserName)
 				goodReview = true
 				break
 			}
@@ -44,45 +149,78 @@ func (r *PRReviews) IsApproved() bool {
 	return goodReview
 }
 
-func (r *PRReviews) HasPendingReviewBy(reviewer string) bool {
-	if !slices.Contains(r.reviewers, reviewer) {
-		return false
+func (r *PRReviews) MissingReviews() []string {
+	missing := []string{}
+	if r == nil {
+		return missing
 	}
 
-	isPending := false
-	for _, r := range r.reviews {
-		if r.User.UserName == reviewer && !r.Stale {
-			switch r.State {
-			case ReviewStateApproved:
-				fallthrough
-			case ReviewStateRequestChanges:
-				return false
-			case ReviewStateRequestReview:
-				fallthrough
-			case ReviewStatePending:
-				isPending = true
-			}
+	for _, reviewer := range r.RequestedReviewers {
+		if !r.IsReviewedBy(reviewer) {
+			missing = append(missing, reviewer)
+		}
+	}
+	return missing
+}
+
+func (r *PRReviews) FindReviewRequester(reviewer string) *models.TimelineComment {
+	if r == nil {
+		return nil
+	}
+
+	for _, r := range r.FullTimeline {
+		if r.Type == TimelineCommentType_ReviewRequested && r.Assignee.UserName == reviewer {
+			return r
 		}
 	}
 
-	return isPending
+	return nil
 }
 
-func (r *PRReviews) IsReviewedBy(reviewer string) bool {
-	if !slices.Contains(r.reviewers, reviewer) {
+func (r *PRReviews) HasPendingReviewBy(reviewer string) bool {
+	if r == nil {
 		return false
 	}
 
-	for _, r := range r.reviews {
-		if r.User.UserName == reviewer && !r.Stale {
+	for _, r := range r.Reviews {
+		if r.User.UserName == reviewer {
 			switch r.State {
-			case ReviewStateApproved:
-				return true
-			case ReviewStateRequestChanges:
+			case ReviewStateRequestReview, ReviewStatePending:
 				return true
+			default:
+				return false
 			}
 		}
 	}
 
 	return false
 }
+
+func (r *PRReviews) IsReviewedBy(reviewer string) bool {
+	if r == nil {
+		return false
+	}
+
+	for _, r := range r.Reviews {
+		if r.User.UserName == reviewer && !r.Stale {
+			switch r.State {
+			case ReviewStateApproved, ReviewStateRequestChanges:
+				return true
+			default:
+				return false
+			}
+		}
+	}
+
+	return false
+}
+
+func (r *PRReviews) IsReviewedByOneOf(reviewers ...string) bool {
+	for _, reviewer := range reviewers {
+		if r.IsReviewedBy(reviewer) {
+			return true
+		}
+	}
+
+	return false
+}

common/reviews_test.go

@@ -14,6 +14,7 @@ func TestReviews(t *testing.T) {
 	tests := []struct {
 		name              string
 		reviews           []*models.PullReview
+		timeline          []*models.TimelineComment
 		reviewers         []string
 		fetchErr          error
 		isApproved        bool
@@ -25,17 +26,17 @@ func TestReviews(t *testing.T) {
 			isApproved: true,
 		},
 		{
-			name:       "Single reviewer done",
-			reviews:    []*models.PullReview{&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}}},
-			reviewers:  []string{"user1"},
-			isApproved: true,
+			name:              "Single reviewer done",
+			reviews:           []*models.PullReview{&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}}},
+			reviewers:         []string{"user1"},
+			isApproved:        true,
 			isReviewedByTest1: true,
 		},
 		{
-			name:       "Two reviewer, one not approved",
-			reviews:    []*models.PullReview{&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}}},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: false,
+			name:              "Two reviewer, one not approved",
+			reviews:           []*models.PullReview{&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}}},
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        false,
 			isReviewedByTest1: true,
 		},
 		{
@@ -44,8 +45,8 @@ func TestReviews(t *testing.T) {
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}},
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}, Stale: true},
 			},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: false,
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        false,
 			isReviewedByTest1: true,
 		},
 		{
@@ -54,18 +55,30 @@ func TestReviews(t *testing.T) {
 				&models.PullReview{State: common.ReviewStateRequestReview, User: &models.User{UserName: "user1"}},
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}},
 			},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: false,
+			reviewers:        []string{"user1", "user2"},
+			isApproved:       false,
 			isPendingByTest1: true,
 		},
 		{
 			name: "Two reviewer, one stale and pending",
 			reviews: []*models.PullReview{
-				&models.PullReview{State: common.ReviewStateRequestReview, User: &models.User{UserName: "user1"}, Stale: true},
+				{State: common.ReviewStateRequestReview, User: &models.User{UserName: "user1"}, Stale: true},
 			},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: false,
-			isPendingByTest1: false,
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        false,
+			isPendingByTest1:  true,
+			isReviewedByTest1: false,
+		},
+		{
+			name: "Two reviewer, one stale and pending, other done",
+			reviews: []*models.PullReview{
+				{State: common.ReviewStateRequestReview, User: &models.User{UserName: "user1"}},
+				{State: common.ReviewStateRequestChanges, User: &models.User{UserName: "user1"}},
+				{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}},
+			},
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        false,
+			isPendingByTest1:  true,
 			isReviewedByTest1: false,
 		},
 		{
@@ -74,8 +87,8 @@ func TestReviews(t *testing.T) {
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}},
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}},
 			},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: true,
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        true,
 			isReviewedByTest1: true,
 		},
 		{
@@ -84,8 +97,8 @@ func TestReviews(t *testing.T) {
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}},
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}, Dismissed: true},
 			},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: false,
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        false,
 			isReviewedByTest1: true,
 		},
 		{
@@ -94,9 +107,9 @@ func TestReviews(t *testing.T) {
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}},
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}},
 			},
-			reviewers:  []string{"user1", "user2"},
-			fetchErr:   errors.New("System error fetching reviews."),
-			isApproved: true,
+			reviewers:         []string{"user1", "user2"},
+			fetchErr:          errors.New("System error fetching reviews."),
+			isApproved:        true,
 			isReviewedByTest1: true,
 		},
 		{
@@ -106,8 +119,23 @@ func TestReviews(t *testing.T) {
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user4"}},
 				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}},
 			},
-			reviewers:  []string{"user1", "user2"},
-			isApproved: true,
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        true,
+			isReviewedByTest1: true,
+		},
+		{
+			name: "Review ignored before push",
+			reviews: []*models.PullReview{
+				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user1"}, ID: 1001},
+				&models.PullReview{State: common.ReviewStateApproved, User: &models.User{UserName: "user2"}, ID: 1000},
+			},
+			timeline: []*models.TimelineComment{
+				&models.TimelineComment{Type: common.TimelineCommentType_Review, ReviewID: 1001},
+				&models.TimelineComment{Type: common.TimelineCommentType_PushPull},
+				&models.TimelineComment{Type: common.TimelineCommentType_Review, ReviewID: 1000},
+			},
+			reviewers:         []string{"user1", "user2"},
+			isApproved:        false,
 			isReviewedByTest1: true,
 		},
 	}
@@ -115,11 +143,15 @@ func TestReviews(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ctl := gomock.NewController(t)
-			rf := mock_common.NewMockGiteaReviewFetcher(ctl)
+			rf := mock_common.NewMockGiteaReviewTimelineFetcher(ctl)
 
+			if test.timeline == nil {
+				test.timeline = reviewsToTimeline(test.reviews)
+			}
+			rf.EXPECT().GetTimeline("test", "pr", int64(1)).Return(test.timeline, nil)
 			rf.EXPECT().GetPullRequestReviews("test", "pr", int64(1)).Return(test.reviews, test.fetchErr)
 
-			reviews, err := common.FetchGiteaReviews(rf, test.reviewers, "test", "pr", 1)
+			reviews, err := common.FetchGiteaReviews(rf, "test", "pr", 1)
 
 			if test.fetchErr != nil {
 				if err != test.fetchErr {
@@ -127,6 +159,7 @@ func TestReviews(t *testing.T) {
 				}
 				return
 			}
+			reviews.RequestedReviewers = test.reviewers
 
 			if r := reviews.IsApproved(); r != test.isApproved {
 				t.Fatal("Unexpected IsReviewed():", r, "vs. expected", test.isApproved)

common/submodules.go

@@ -113,6 +113,10 @@ func (s *Submodule) parseKeyValue(line string) error {
 	return nil
 }
 
+func (s *Submodule) ManifestSubmodulePath(manifest *Manifest) string {
+	return manifest.SubdirForPackage(s.Path)
+}
+
 func ParseSubmodulesFile(reader io.Reader) ([]Submodule, error) {
 	data, err := io.ReadAll(reader)
 	if err != nil {

common/timeline.go

@@ -8,20 +8,20 @@ import (
 )
 
 const (
-	CommentType_ReviewRequested = "review_request"
-	CommentType_Review          = "review"
-	CommentType_PushPull        = "pull_push"
-	CommentType_DismissReview   = "dismiss_review"
+	TimelineCommentType_ReviewRequested = "review_request"
+	TimelineCommentType_Review          = "review"
+	TimelineCommentType_PushPull        = "pull_push"
+	TimelineCommentType_PullRequestRef  = "pull_ref"
+	TimelineCommentType_DismissReview   = "dismiss_review"
+	TimelineCommentType_Comment         = "comment"
 )
 
-func FetchTimelineSinceReviewRequestOrPush(gitea GiteaTimelineFetcher, groupName, headSha, org, repo string, id int64) ([]*models.TimelineComment, error) {
+func FetchTimelineSinceLastPush(gitea GiteaTimelineFetcher, headSha, org, repo string, id int64) ([]*models.TimelineComment, error) {
 	timeline, err := gitea.GetTimeline(org, repo, id)
 	if err != nil {
 		return nil, err
 	}
 
-	idx := len(timeline) - 1
-
 	//{"is_force_push":true,"commit_ids":["36e43509be1b13a1a8fc63a4361405de04cc621ab16935f88968c46193221bb6","732246a48fbc6bac9df16c0b0ca23ce0f6fbabd9990795863b6d1f0ef3f242c8"]}
 	type PullPushData struct {
 		IsForcePush bool     `json:"is_force_push"`
@@ -29,24 +29,35 @@ func FetchTimelineSinceReviewRequestOrPush(gitea GiteaTimelineFetcher, groupName
 	}
 
 	// trim timeline to last push update or last time review request was requested
-	for ; idx > 0; idx-- {
-		e := timeline[idx]
-		if e.Type == CommentType_PushPull {
+	for i, e := range timeline {
+		if e.Type == TimelineCommentType_PushPull {
 			var push PullPushData
 			if err := json.Unmarshal([]byte(e.Body), &push); err != nil {
 				LogError(err)
 			}
 
 			if slices.Contains(push.CommitIds, headSha) {
-				break
+				return timeline[0:i], nil
 			}
-		} else if e.Type == CommentType_ReviewRequested && e.Assignee != nil && e.Assignee.UserName == groupName {
-			// review request is cut-off for reviews too
-			break
 		}
 	}
 
-	timeline = timeline[idx:]
 	return timeline, nil
 }
 
+func FetchTimelineSinceReviewRequestOrPush(gitea GiteaTimelineFetcher, groupName, headSha, org, repo string, id int64) ([]*models.TimelineComment, error) {
+	timeline, err := FetchTimelineSinceLastPush(gitea, headSha, org, repo, id)
+	if err != nil {
+		return nil, err
+	}
+
+	// trim timeline to last push update or last time review request was requested
+	for i, e := range timeline {
+		if e.Type == TimelineCommentType_ReviewRequested && e.Assignee != nil && e.Assignee.UserName == groupName {
+			// review request is cut-off for reviews too
+			return timeline[0:i], nil
+		}
+	}
+
+	return timeline, nil
+}

common/tsetup.sh

@@ -1,6 +1,10 @@
 #!/usr/bin/bash
 
 git init -q --bare --object-format=sha256
+git config user.email test@example.com
+git config user.name Test
+export GIT_AUTHOR_DATE=2025-10-27T14:20:07+01:00
+export GIT_COMMITTER_DATE=2025-10-27T14:20:07+01:00
 
 # 81aba862107f1e2f5312e165453955485f424612f313d6c2fb1b31fef9f82a14
 blobA=$(echo "help" | git hash-object --stdin -w)

common/utils.go

@@ -19,13 +19,95 @@ package common
  */
 
 import (
+	"bufio"
+	"errors"
 	"fmt"
+	"net/http"
 	"net/url"
 	"regexp"
 	"slices"
 	"strings"
+	"unicode"
+
+	"src.opensuse.org/autogits/common/gitea-generated/models"
 )
 
+type NewRepos struct {
+	Repos []struct {
+		Organization, Repository, Branch string
+		PackageName                      string
+	}
+	IsMaintainer bool
+}
+
+const maintainership_line = "MAINTAINER"
+
+var true_lines []string = []string{"1", "TRUE", "YES", "OK", "T"}
+
+func HasSpace(s string) bool {
+	return strings.IndexFunc(s, unicode.IsSpace) >= 0
+}
+
+func FindNewReposInIssueBody(body string) *NewRepos {
+	Issues := &NewRepos{}
+	for _, line := range strings.Split(body, "\n") {
+		line = strings.TrimSpace(line)
+		if ul := strings.ToUpper(line); strings.HasPrefix(ul, "MAINTAINER") {
+			value := ""
+			if idx := strings.IndexRune(ul, ':'); idx > 0 && len(ul) > idx+2 {
+				value = ul[idx+1:]
+			} else if idx := strings.IndexRune(ul, ' '); idx > 0 && len(ul) > idx+2 {
+				value = ul[idx+1:]
+			}
+
+			if slices.Contains(true_lines, strings.TrimSpace(value)) {
+				Issues.IsMaintainer = true
+			}
+		}
+		// line = strings.TrimSpace(line)
+		issue := struct{ Organization, Repository, Branch, PackageName string }{}
+
+		branch := strings.Split(line, "#")
+		repo := strings.Split(branch[0], "/")
+
+		if len(branch) == 2 {
+			issue.Branch = strings.TrimSpace(branch[1])
+		}
+		if len(repo) == 2 {
+			issue.Organization = strings.TrimSpace(repo[0])
+			issue.Repository = strings.TrimSpace(repo[1])
+			issue.PackageName = issue.Repository
+
+			if idx := strings.Index(strings.ToUpper(issue.Branch), " AS "); idx > 0 && len(issue.Branch) > idx+5 {
+				issue.PackageName = strings.TrimSpace(issue.Branch[idx+3:])
+				issue.Branch = strings.TrimSpace(issue.Branch[0:idx])
+			}
+
+			if HasSpace(issue.Organization) || HasSpace(issue.Repository) || HasSpace(issue.PackageName) || HasSpace(issue.Branch) {
+				continue
+			}
+		} else {
+			continue
+		}
+		Issues.Repos = append(Issues.Repos, issue)
+		//PackageNameIdx := strings.Index(strings.ToUpper(line), " AS ")
+		//words := strings.Split(line)
+	}
+
+	if len(Issues.Repos) == 0 {
+		return nil
+	}
+	return Issues
+}
+
+func IssueToString(issue *models.Issue) string {
+	if issue == nil {
+		return "(nil)"
+	}
+
+	return fmt.Sprintf("%s/%s#%d", issue.Repository.Owner, issue.Repository.Name, issue.Index)
+}
+
 func SplitLines(str string) []string {
 	return SplitStringNoEmpty(str, "\n")
 }
@@ -49,6 +131,10 @@ func TranslateHttpsToSshUrl(url string) (string, error) {
 		url2_len = len(url2)
 	)
 
+	if len(url) > 10 && (url[0:10] == "gitea@src." || url[0:10] == "ssh://gite") {
+		return url, nil
+	}
+
 	if len(url) > url1_len && url[0:url1_len] == url1 {
 		return "ssh://gitea@src.opensuse.org/" + url[url1_len:], nil
 	}
@@ -121,3 +207,82 @@ func (giturl *GitUrl) RemoteName() string {
 
 	return strings.ToLower(giturl.Org) + "_" + strings.ToLower(giturl.Repo)
 }
+
+func PRtoString(pr *models.PullRequest) string {
+	if pr == nil {
+		return "(null)"
+	}
+
+	return fmt.Sprintf("%s/%s!%d", pr.Base.Repo.Owner.UserName, pr.Base.Repo.Name, pr.Index)
+}
+
+type DevelProject struct {
+	Project, Package string
+}
+
+type DevelProjects []*DevelProject
+
+func FetchDevelProjects() (DevelProjects, error) {
+	res, err := http.Get("https://src.opensuse.org/openSUSE/Factory/raw/branch/main/pkgs/_meta/devel_packages")
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	scanner := bufio.NewScanner(res.Body)
+	ret := []*DevelProject{}
+	for scanner.Scan() {
+		d := SplitStringNoEmpty(scanner.Text(), " ")
+		if len(d) == 2 {
+			ret = append(ret, &DevelProject{
+				Project: d[1],
+				Package: d[0],
+			})
+		}
+	}
+
+	return ret, nil
+}
+
+var DevelProjectNotFound = errors.New("Devel project not found")
+
+func (d DevelProjects) GetDevelProject(pkg string) (string, error) {
+	for _, item := range d {
+		if item.Package == pkg {
+			return item.Project, nil
+		}
+	}
+
+	return "", DevelProjectNotFound
+}
+
+var removedBranchNameSuffixes []string = []string{
+	"-rm",
+	"-removed",
+	"-deleted",
+}
+
+func findRemovedBranchSuffix(branchName string) string {
+	branchName = strings.ToLower(branchName)
+
+	for _, suffix := range removedBranchNameSuffixes {
+		if len(suffix) < len(branchName) && strings.HasSuffix(branchName, suffix) {
+			return suffix
+		}
+	}
+
+	return ""
+}
+
+func IsRemovedBranch(branchName string) bool {
+	return len(findRemovedBranchSuffix(branchName)) > 0
+}
+
+func TrimRemovedBranchSuffix(branchName string) string {
+	suffix := findRemovedBranchSuffix(branchName)
+	if len(suffix) > 0 {
+		return branchName[0 : len(branchName)-len(suffix)]
+	}
+
+	return branchName
+}

common/utils_test.go

@@ -1,6 +1,7 @@
 package common_test
 
 import (
+	"reflect"
 	"testing"
 
 	"src.opensuse.org/autogits/common"
@@ -165,3 +166,142 @@ func TestRemoteName(t *testing.T) {
 		})
 	}
 }
+
+func TestRemovedBranchName(t *testing.T) {
+	tests := []struct {
+		name        string
+		branchName  string
+		isRemoved   bool
+		regularName string
+	}{
+		{
+			name: "Empty branch",
+		},
+		{
+			name:        "Removed suffix only",
+			branchName:  "-rm",
+			isRemoved:   false,
+			regularName: "-rm",
+		},
+		{
+			name:        "Capital suffix",
+			branchName:  "Foo-Rm",
+			isRemoved:   true,
+			regularName: "Foo",
+		},
+		{
+			name:        "Other suffixes",
+			isRemoved:   true,
+			branchName:  "Goo-Rm-DeleteD",
+			regularName: "Goo-Rm",
+		},
+		{
+			name:        "Other suffixes",
+			isRemoved:   true,
+			branchName:  "main-REMOVED",
+			regularName: "main",
+		},
+		{
+			name:        "Not removed separator",
+			isRemoved:   false,
+			branchName:  "main;REMOVED",
+			regularName: "main;REMOVED",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if r := common.IsRemovedBranch(test.branchName); r != test.isRemoved {
+				t.Error("Expecting isRemoved:", test.isRemoved, "but received", r)
+			}
+
+			if tn := common.TrimRemovedBranchSuffix(test.branchName); tn != test.regularName {
+				t.Error("Expected stripped branch name to be:", test.regularName, "but have:", tn)
+			}
+		})
+	}
+}
+
+func TestNewPackageIssueParsing(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  string
+		issues *common.NewRepos
+	}{
+		{
+			name: "Nothing",
+		},
+		{
+			name:  "Basic repo",
+			input: "org/repo#branch",
+			issues: &common.NewRepos{
+				Repos: []struct{ Organization, Repository, Branch, PackageName string }{
+					{Organization: "org", Repository: "repo", Branch: "branch", PackageName: "repo"},
+				},
+			},
+		},
+		{
+			name: "Default branch and junk lines and approval for maintainership",
+			input: "\n\nsome comments\n\norg1/repo2\n\nmaintainership: yes",
+			issues: &common.NewRepos{
+				Repos: []struct{ Organization, Repository, Branch, PackageName string }{
+					{Organization: "org1", Repository: "repo2", Branch: "", PackageName: "repo2"},
+				},
+				IsMaintainer: true,
+			},
+		},
+		{
+			name: "Default branch and junk lines and no maintainership",
+			input: "\n\nsome comments\n\norg1/repo2\n\nmaintainership: NEVER",
+			issues: &common.NewRepos{
+				Repos: []struct{ Organization, Repository, Branch, PackageName string }{
+					{Organization: "org1", Repository: "repo2", Branch: "", PackageName: "repo2"},
+				},
+			},
+		},
+		{
+			name: "3 repos with comments and maintainership",
+			input: "\n\nsome comments for org1/repo2 are here and more\n\norg1/repo2#master\n    org2/repo3#master\n   some/repo3#m\nMaintainer ok",
+			issues: &common.NewRepos{
+				Repos: []struct{ Organization, Repository, Branch, PackageName string }{
+					{Organization: "org1", Repository: "repo2", Branch: "master", PackageName: "repo2"},
+					{Organization: "org2", Repository: "repo3", Branch: "master", PackageName: "repo3"},
+					{Organization: "some", Repository: "repo3", Branch: "m", PackageName: "repo3"},
+				},
+				IsMaintainer: true,
+			},
+		},
+		{
+			name: "Invalid repos with spaces",
+			input: "or g/repo#branch\norg/r epo#branch\norg/repo#br anch\norg/repo#branch As foo ++",
+		},
+		{
+			name: "Valid repos with spaces",
+			input: " org / repo # branch",
+			issues: &common.NewRepos{
+				Repos: []struct{ Organization, Repository, Branch, PackageName string }{
+					{Organization: "org", Repository: "repo", Branch: "branch", PackageName: "repo"},
+				},
+			},
+		},
+		{
+			name: "Package name is not repo name",
+			input: " org / repo # branch    as  repo++ \nmaintainer true",
+			issues: &common.NewRepos{
+				Repos: []struct{ Organization, Repository, Branch, PackageName string }{
+					{Organization: "org", Repository: "repo", Branch: "branch", PackageName: "repo++"},
+				},
+				IsMaintainer: true,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			issue := common.FindNewReposInIssueBody(test.input)
+			if !reflect.DeepEqual(test.issues, issue) {
+				t.Error("Expected", test.issues, "but have", issue)
+			}
+		})
+	}
+}

containers/Makefile

@@ -0,0 +1,8 @@
+all: ../workflow-direct/workflow-direct
+	cp ../workflow-direct/workflow-direct workflow-direct
+	podman build --pull=always -t workflow-direct workflow-direct
+
+pr:
+	cp ../workflow-pr/workflow-pr workflow-pr
+	podman build --pull=always -t workflow-pr workflow-pr
+

containers/workflow-direct/.gitignore

@@ -0,0 +1 @@
+workflow-direct

containers/workflow-direct/Containerfile

@@ -0,0 +1,14 @@
+FROM registry.suse.com/bci/bci-base
+RUN zypper install -y openssh-clients git-core
+RUN mkdir /root/.ssh
+RUN mkdir /repos
+RUN ln -s /data/workflow-direct.key        /root/.ssh/id_ed25519
+RUN ln -s /data/workflow-direct.key.pub    /root/.ssh/id_ed25519.pub
+ADD known_hosts /root/.ssh/known_hosts
+ADD workflow-direct   /srv/workflow-direct
+ENV AMQP_USERNAME=opensuse
+ENV AMQP_PASSWORD=opensuse
+VOLUME /data
+VOLUME /repos
+ENTRYPOINT /srv/workflow-direct -config /data/config.json -repo-path /repos -debug -check-on-start
+

containers/workflow-direct/known_hosts

@@ -0,0 +1,4 @@
+src.opensuse.org,195.135.223.224 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBDJ8V51MVIFUkQqQOdHwC3SP9NPqp1ZWYoEbcjvZ7HhSFi2XF8ALo/h1Mk+q8kT2O75/goeTsKFbcU8zrYFeOh0=
+src.opensuse.org,195.135.223.224 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCkVeXePin0haffC085V2L0jvILfwbB2Mt1fpVe21QAOcWNM+/jOC5RwtWweV/LigHImB39/KvkuPa9yLoDf+eLhdZQckSSauRfDjxtlKeFLPrfJKSA0XeVJT3kJcOvDT/3ANFhYeBbAUBTAeQt5bi2hHC1twMPbaaEdJ2jiMaIBztFf6aE9K58uoS+7Y2tTv87Mv/7lqoBW6BFMoDmjQFWgjik6ZMCvIM/7bj7AgqHk/rjmr5zKS4ag5wtHtYLm1L3LBmHdj7d0VFsOpPQexIOEnnjzKqlwmAxT6eYJ/t3qgBlT8KRfshBFgEuUZ5GJOC7TOne4PfB0bboPMZzIRo3WE9dPGRR8kAIme8XqhFbmjdJ+WsTjg0Lj+415tIbyRQoNkLtawrJxozvevs6wFEFcA/YG6o03Z577tiLT3WxOguCcD5vrALH48SyZb8jDUtcVgTWMW0to/n63S8JGUNyF7Bkw9HQWUx+GO1cv2GNzKpk22KS5dlNUVGE9E/7Ydc=
+src.opensuse.org,195.135.223.224 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFKNThLRPznU5Io1KrAYHmYpaoLQEMGM9nwpKyYQCkPx
+

containers/workflow-pr/.gitignore

@@ -0,0 +1 @@
+workflow-pr

containers/workflow-pr/Containerfile

@@ -0,0 +1,14 @@
+FROM registry.suse.com/bci/bci-base
+RUN zypper install -y openssh-clients git-core
+RUN mkdir /root/.ssh
+RUN mkdir /repos
+RUN ln -s /data/workflow-pr.key        /root/.ssh/id_ed25519
+RUN ln -s /data/workflow-pr.key.pub    /root/.ssh/id_ed25519.pub
+ADD known_hosts /root/.ssh/known_hosts
+ADD workflow-pr   /srv/workflow-pr
+ENV AMQP_USERNAME=opensuse
+ENV AMQP_PASSWORD=opensuse
+VOLUME /data
+VOLUME /repos
+ENTRYPOINT /srv/workflow-pr -config /data/config.json -repo-path /repos -debug -check-on-start
+

containers/workflow-pr/known_hosts

@@ -0,0 +1,4 @@
+src.opensuse.org,195.135.223.224 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBDJ8V51MVIFUkQqQOdHwC3SP9NPqp1ZWYoEbcjvZ7HhSFi2XF8ALo/h1Mk+q8kT2O75/goeTsKFbcU8zrYFeOh0=
+src.opensuse.org,195.135.223.224 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCkVeXePin0haffC085V2L0jvILfwbB2Mt1fpVe21QAOcWNM+/jOC5RwtWweV/LigHImB39/KvkuPa9yLoDf+eLhdZQckSSauRfDjxtlKeFLPrfJKSA0XeVJT3kJcOvDT/3ANFhYeBbAUBTAeQt5bi2hHC1twMPbaaEdJ2jiMaIBztFf6aE9K58uoS+7Y2tTv87Mv/7lqoBW6BFMoDmjQFWgjik6ZMCvIM/7bj7AgqHk/rjmr5zKS4ag5wtHtYLm1L3LBmHdj7d0VFsOpPQexIOEnnjzKqlwmAxT6eYJ/t3qgBlT8KRfshBFgEuUZ5GJOC7TOne4PfB0bboPMZzIRo3WE9dPGRR8kAIme8XqhFbmjdJ+WsTjg0Lj+415tIbyRQoNkLtawrJxozvevs6wFEFcA/YG6o03Z577tiLT3WxOguCcD5vrALH48SyZb8jDUtcVgTWMW0to/n63S8JGUNyF7Bkw9HQWUx+GO1cv2GNzKpk22KS5dlNUVGE9E/7Ydc=
+src.opensuse.org,195.135.223.224 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFKNThLRPznU5Io1KrAYHmYpaoLQEMGM9nwpKyYQCkPx
+

devel-importer/.gitignore

@@ -2,3 +2,4 @@ devel-importer
 Factory
 git
 git-migrated
+git-importer

devel-importer/find_factory_commit.pl

@@ -0,0 +1,239 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use IPC::Open2;
+use JSON;
+
+sub FindFactoryCommit {
+    my ($package) = @_;
+
+    # Execute osc cat and capture output
+    my $osc_cmd = "osc cat openSUSE:Factory $package $package.changes";
+    open( my $osc_fh, "$osc_cmd |" ) or die "Failed to run osc: $!";
+    my $data = do { local $/; <$osc_fh> };
+    close($osc_fh);
+
+    # Calculate size
+    my $size = length($data);
+
+    # Create blob header
+    my $blob = "blob $size\0$data";
+
+    # Open a pipe to openssl to compute the hash
+    my ( $reader, $writer );
+    my $pid = open2( $reader, $writer, "openssl sha256" );
+
+    # Send blob data
+    print $writer $blob;
+    close $writer;
+
+    # Read the hash result and extract it
+    my $hash_line = <$reader>;
+    waitpid( $pid, 0 );
+    my ($hash) = $hash_line =~ /([a-fA-F0-9]{64})/;
+
+    # Run git search command with the hash
+    print("looking for hash: $hash\n");
+    my @hashes;
+    my $git_cmd =
+"git -C $package rev-list --all pool/HEAD | while read commit; do git -C $package ls-tree \"\$commit\" | grep -q '^100644 blob $hash' && echo \"\$commit\"; done";
+    open( my $git_fh, "$git_cmd |" ) or die "Failed to run git search: $!";
+    while ( my $commit = <$git_fh> ) {
+        chomp $commit;
+        print "Found commit $commit\n";
+        push( @hashes, $commit );
+    }
+    close($git_fh);
+    return @hashes;
+}
+
+sub ListPackages {
+    my ($project) = @_;
+    open( my $osc_fh,
+        "curl -s https://src.opensuse.org/openSUSE/Factory/raw/branch/main/pkgs/_meta/devel_packages | awk '{ if ( \$2 == \"$project\" ) print \$1 }' |" )
+      or die "Failed to run curl: $!";
+    my @packages = <$osc_fh>;
+    chomp @packages;
+    close($osc_fh);
+    return @packages;
+}
+
+sub FactoryMd5 {
+	my ($package) = @_;
+	my $out = "";
+
+	if (system("osc ls openSUSE:Factory $package | grep -q build.specials.obscpio") == 0) {
+		system("mkdir _extract") == 0 || die "_extract exists or can't make it. Aborting.";
+		chdir("_extract") || die;
+		system("osc cat openSUSE:Factory $package build.specials.obscpio | cpio -dium 2> /dev/null") == 0 || die;
+		system("rm .* 2> /dev/null");
+		open( my $fh, "find -type f -exec /usr/bin/basename {} \\; | xargs md5sum | awk '{print \$1 FS \$2}' | grep -v d41d8cd98f00b204e9800998ecf8427e |") or die;
+		while ( my $l = <$fh>) {
+			$out = $out.$l;
+		}
+		close($fh);
+		chdir("..") && system("rm -rf _extract") == 0 || die;
+	}
+	open( my $fh, "osc ls -v openSUSE:Factory $package | awk '{print \$1 FS \$7}' | grep -v -F '_scmsync.obsinfo\nbuild.specials.obscpio' |") or die;
+	while (my $l = <$fh>) {
+		$out = $out.$l;
+	}
+	close($fh);
+	return $out;
+}
+
+# Read project from first argument
+sub Usage {
+    die "Usage: $0 <OBS Project> [org [package]]";
+}
+
+my $project = shift or Usage();
+my $org     = shift;
+
+if (not defined($org)) {
+    $org = `osc meta prj $project | grep scmsync | sed -e 's,^.*src.opensuse.org/\\(.*\\)/_ObsPrj.*,\\1,'`;
+    chomp($org);
+}
+
+my @packages = ListPackages($project);
+my $pkg      = shift;
+@packages = ($pkg) if defined $pkg;
+
+my @tomove;
+my @toremove;
+
+if ( ! -e $org ) {
+    mkdir($org);
+}
+chdir($org);
+print "Verify packages in /pool for $org package in $project\n";
+
+my $super_user = $ENV{SUPER};
+if (defined($super_user)) {
+    $super_user = "-G $super_user";
+} else {
+    $super_user = "";
+}
+
+my @missing;
+
+# verify that packages in devel project is a fork from pool.
+for my $pkg ( sort(@packages) ) {
+    my $data = `git obs api /repos/$org/$pkg 2> /dev/null`;
+    if ( length($data) == 0 ) {
+        print "***** Repo missing in $org: $pkg\n";
+	push(@missing, $pkg);
+	next;
+    }
+    else {
+        my $repo = decode_json($data);
+        if (  !$repo->{parent}
+            || $repo->{parent}->{owner}->{username} ne "pool" )
+        {
+            if ( system("git obs api /repos/pool/$pkg > /dev/null 2> /dev/null") == 0 ) {
+                print "=== $pkg NOT A FORK of exiting package\n";
+                push( @toremove, $pkg );
+            }
+            else {
+                print "$pkg NEEDS transfer\n";
+                push( @tomove, $pkg );
+            }
+        }
+    }
+}
+
+if ( scalar @missing > 0 ) {
+    for my $pkg (@missing) {
+        my $index = 0;
+        $index++ until $packages[$index] eq $pkg;
+        splice(@packages, $index, 1);
+    }
+}
+
+if ( scalar @toremove > 0 ) {
+    print "ABORTING. Need repos removed.\n";
+    print "@toremove\n";
+    exit(1);
+}
+
+if ( scalar @tomove > 0 ) {
+    for my $pkg (@tomove) {
+        system("git obs $super_user api -X POST --data '{\"reparent\": true, \"organization\": \"pool\"}' /repos/$org/$pkg/forks") == 0 and
+        system("git clone gitea\@src.opensuse.org:pool/$pkg") == 0 and
+        system("git -C $pkg checkout -B factory HEAD") == 0 and
+        system("git -C $pkg push origin factory") == 0 and
+        system("git obs $super_user api -X PATCH --data '{\"default_branch\": \"factory\"}' /repos/pool/$pkg") == 0
+            or die "Error in creating a pool repo";
+        system("for i in \$(git -C $pkg for-each-ref --format='%(refname:lstrip=3)' refs/remotes/origin/ | grep -v '\\(^HEAD\$\\|^factory\$\\)'); do git -C $pkg push origin :\$i; done") == 0 or die "failed to cull branches";
+    }
+}
+
+print "Verify complete.\n";
+
+for my $package ( sort(@packages) ) {
+    print " ----- PROCESSING $package\n";
+    my $url      = "https://src.opensuse.org/$org/$package.git";
+    my $push_url = "gitea\@src.opensuse.org:pool/$package.git";
+    if ( not -e $package ) {
+        print("cloning...\n");
+        system("git clone --origin pool $url") == 0
+          or die "Can't clone $org/$package";
+    }
+    else {
+        print("adding remote...\n");
+        system("git -C $package remote rm pool > /dev/null");
+        system("git -C $package remote add pool $url") == 0
+          or die "Can't add pool for $package";
+    }
+    system("git -C $package remote set-url pool --push $push_url") == 0
+      or die "Can't add push remote for $package";
+    print("fetching remote...\n");
+    system("git -C $package fetch pool") == 0
+      or ( push( @tomove, $package ) and die "Can't fetch pool for $package" );
+
+    my @commits = FindFactoryCommit($package);
+    my $Md5Hashes = FactoryMd5($package);
+    my $c;
+    my $match = 0;
+    for my $commit (@commits) {
+        if ( length($commit) != 64 ) {
+            print("Failed to find factory commit. Aborting.");
+            exit(1);
+        }
+
+        if (
+                system("git -C $package lfs fetch pool $commit") == 0
+            and system("git -C $package checkout -B factory $commit") == 0
+            and system("git -C $package lfs checkout") == 0
+            and chdir($package)) {
+
+	    open(my $fh, "|-", "md5sum -c --quiet") or die $!;
+            print $fh $Md5Hashes;
+            close $fh;
+	    if ($? >> 8 != 0) {
+		    chdir("..") || die;
+		    next;
+	    }
+	    open($fh, "|-", "awk '{print \$2}' | sort | bash -c \"diff <(ls -1 | sort) -\"") or die $!;
+	    print $fh $Md5Hashes;
+            close $fh;
+            my $ec = $? >> 8;
+	    chdir("..") || die;
+
+	    if ($ec == 0) {
+               $c     = $commit;
+               $match = 1;
+               last;
+	    }
+
+        }
+    }
+
+    if ( !$match ) {
+        die "Match not found. Aborting.";
+    }
+
+    system ("git -C $package push -f pool factory");
+    print "$package: $c\n";
+}
+

devel-importer/migrated_projects

@@ -1,15 +1,24 @@
+Java:packages
 Kernel:firmware
 Kernel:kdump
+devel:gcc
 devel:languages:clojure
 devel:languages:erlang
 devel:languages:erlang:Factory
 devel:languages:hare
 devel:languages:javascript
 devel:languages:lua
+devel:languages:nodejs
+devel:languages:perl
+devel:languages:python:Factory
+devel:languages:python:pytest
+devel:openSUSE:Factory
+network:chromium
 network:dhcp
 network:im:whatsapp
 network:messaging:xmpp
+science:HPC
+server:dns
 systemsmanagement:cockpit
-systemsmanagement:wbem
 X11:lxde
 

gitea-events-rabbitmq-publisher/main.go

@@ -298,6 +298,22 @@ func parseRequestJSONOrg(reqType string, data []byte) (org *common.Organization,
 		org = pr.Repository.Owner
 		extraAction = ""
 
+	case common.RequestType_Status:
+		status := common.StatusWebhookEvent{}
+		if err = json.Unmarshal(data, &status); err != nil {
+			return
+		}
+		switch status.State {
+		case "pending", "success", "error", "failure":
+			break
+		default:
+			err = fmt.Errorf("Unknown Status' state: %s", status.State)
+			return
+		}
+
+		org = status.Repository.Owner
+		extraAction = status.State
+
 	case common.RequestType_Wiki:
 		wiki := common.WikiWebhookEvent{}
 		if err = json.Unmarshal(data, &wiki); err != nil {

gitea_status_proxy/config.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/tailscale/hujson"
+)
+
+type Config struct {
+	ForgeEndpoint string   `json:"forge_url"`
+	Keys          []string `json:"keys"`
+}
+
+type contextKey string
+
+const configKey contextKey = "config"
+
+func ReadConfig(reader io.Reader) (*Config, error) {
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		return nil, fmt.Errorf("error reading config data: %w", err)
+	}
+	config := Config{}
+	data, err = hujson.Standardize(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse json: %w", err)
+	}
+	if err := json.Unmarshal(data, &config); err != nil {
+		return nil, fmt.Errorf("error parsing json to api keys and target url: %w", err)
+	}
+
+	return &config, nil
+}
+
+func ReadConfigFile(filename string) (*Config, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("cannot open config file for reading. err: %w", err)
+	}
+	defer file.Close()
+
+	return ReadConfig(file)
+}

gitea_status_proxy/handlers.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"context"
+	"net/http"
+)
+
+func ConfigMiddleWare(cfg *Config) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := context.WithValue(r.Context(), configKey, cfg)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}

gitea_status_proxy/main.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"slices"
+	"strings"
+
+	"src.opensuse.org/autogits/common"
+)
+
+type StatusInput struct {
+	Description string `json:"description"`
+	Context     string `json:"context"`
+	State       string `json:"state"`
+	TargetUrl   string `json:"target_url"`
+}
+
+func main() {
+	configFile := flag.String("config", "", "status proxy config file")
+	flag.Parse()
+
+	if *configFile == "" {
+		common.LogError("missing required argument config")
+		return
+	}
+
+	config, err := ReadConfigFile(*configFile)
+
+	if err != nil {
+		common.LogError("Failed to read config file", err)
+		return
+	}
+
+	mux := http.NewServeMux()
+
+	mux.Handle("/repos/{owner}/{repo}/statuses/{sha}", ConfigMiddleWare(config)(http.HandlerFunc(StatusProxy)))
+
+	common.LogInfo("server up and listening on :3000")
+	err = http.ListenAndServe(":3000", mux)
+
+	if err != nil {
+		common.LogError("Server failed to start up", err)
+	}
+
+}
+
+func StatusProxy(w http.ResponseWriter, r *http.Request) {
+	if r.Method == http.MethodPost {
+		config, ok := r.Context().Value(configKey).(*Config)
+
+		if !ok {
+			common.LogDebug("Config missing from context")
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			return
+		}
+
+		header := r.Header.Get("Authorization")
+		if header == "" {
+			common.LogDebug("Authorization header not found")
+			http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
+			return
+		}
+		token_arr := strings.Split(header, " ")
+		if len(token_arr) != 2 {
+			common.LogDebug("Authorization header malformed")
+			http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
+			return
+		}
+
+		if !strings.EqualFold(token_arr[0], "token") {
+			common.LogDebug("Token not found in Authorization header")
+			http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
+			return
+		}
+
+		token := token_arr[1]
+
+		if !slices.Contains(config.Keys, token) {
+			common.LogDebug("Provided token is not known")
+			http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
+			return
+		}
+
+		owner := r.PathValue("owner")
+		repo := r.PathValue("repo")
+		sha := r.PathValue("sha")
+
+		if !ok {
+			common.LogError("Failed to get config from context, is it set?")
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		}
+
+		posturl := fmt.Sprintf("%s/repos/%s/%s/statuses/%s", config.ForgeEndpoint, owner, repo, sha)
+		decoder := json.NewDecoder(r.Body)
+		var statusinput StatusInput
+		err := decoder.Decode(&statusinput)
+		if err != nil {
+			http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+			return
+		}
+
+		status_payload, err := json.Marshal(statusinput)
+
+		if err != nil {
+			http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+			return
+		}
+		client := &http.Client{}
+		req, err := http.NewRequest("POST", posturl, bytes.NewBuffer(status_payload))
+
+		if err != nil {
+			http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+			return
+		}
+		ForgeToken := os.Getenv("GITEA_TOKEN")
+
+		if ForgeToken == "" {
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			common.LogError("GITEA_TOKEN was not set, all requests will fail")
+			return
+		}
+
+		req.Header.Add("Content-Type", "application/json")
+		req.Header.Add("Authorization", fmt.Sprintf("token %s", ForgeToken))
+
+		resp, err := client.Do(req)
+
+		if err != nil {
+			common.LogError(fmt.Sprintf("Request to forge endpoint failed: %v", err))
+			http.Error(w, http.StatusText(http.StatusBadGateway), http.StatusBadGateway)
+			return
+		}
+		defer resp.Body.Close()
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(resp.StatusCode)
+
+		/*
+			the commented out section sets every key
+			value from the headers, unsure if this
+			leaks information from gitea
+
+			for k, v := range resp.Header {
+				for _, vv := range v {
+					w.Header().Add(k, vv)
+				}
+			}
+		*/
+
+		_, err = io.Copy(w, resp.Body)
+		if err != nil {
+			common.LogError("Error copying response body: %v", err)
+		}
+	} else {
+		http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
+		return
+	}
+}

gitea_status_proxy/readme.md

@@ -0,0 +1,48 @@
+# gitea_status_proxy
+
+Allows bots without code owner permission to set Gitea's commit status
+
+## Basic usage
+
+To beging, you need the json config and a Gitea token with permissions to the repository you want to write to.
+
+Keys should be randomly generated, i.e by using openssl: `openssl rand -base64 48`
+
+Generate a json config file, with the key generated from running the command above, save as example.json:
+
+```
+{
+	"forge_url": "https://src.opensuse.org/api/v1",
+	"keys": ["$YOUR_TOKEN_GOES_HERE"]
+}
+```
+
+### start the proxy:
+
+```
+GITEA_TOKEN=YOURTOKEN ./gitea_status_proxy -config example.json
+2025/10/30 12:53:18 [I] server up and listening on :3000
+```
+
+Now the proxy should be able to accept requests under: `localhost:3000/repos/{owner}/{repo}/statuses/{sha}`, the token to be used when authenticating to the proxy must be in the `keys` list of the configuration json file (example.json above)
+
+### example:
+
+On a separate terminal, you can use curl to post a status to the proxy, if the GITEA_TOKEN has permissions on the target
+repository, it will result in a new status being set for the given commit
+
+```
+curl -X 'POST' \
+  'localhost:3000/repos/szarate/test-actions-gitea/statuses/cd5847c92fb65a628bdd6015f96ee7e569e1ad6e4fc487acc149b52e788262f9' \
+  -H 'accept: application/json' \
+  -H 'Authorization: token $YOUR_TOKEN_GOES_HERE' \
+  -H 'Content-Type: application/json' \
+  -d '{
+  "context": "Proxy test",
+  "description": "Status posted from the proxy",
+  "state": "success",
+  "target_url": "https://src.opensuse.org"
+}'
+```
+
+After this you should be able to the results in the pull request, e.g from above: https://src.opensuse.org/szarate/test-actions-gitea/pulls/1

go.mod

@@ -10,12 +10,16 @@ require (
 	github.com/go-openapi/validate v0.24.0
 	github.com/opentracing/opentracing-go v1.2.0
 	github.com/rabbitmq/amqp091-go v1.10.0
+	github.com/redis/go-redis/v9 v9.11.0
 	github.com/tailscale/hujson v0.0.0-20250226034555-ec1d1c113d33
 	go.uber.org/mock v0.5.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-openapi/analysis v0.23.0 // indirect
@@ -33,5 +37,4 @@ require (
 	go.opentelemetry.io/otel/metric v1.24.0 // indirect
 	go.opentelemetry.io/otel/trace v1.24.0 // indirect
 	golang.org/x/sync v0.7.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,8 +1,16 @@
 github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
 github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
 github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
@@ -50,6 +58,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw=
 github.com/rabbitmq/amqp091-go v1.10.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o=
+github.com/redis/go-redis/v9 v9.11.0 h1:E3S08Gl/nJNn5vkxd2i78wZxWAPNZgUNTp8WIJUAiIs=
+github.com/redis/go-redis/v9 v9.11.0/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6Q5lHuCH/Iw=
 github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
 github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

group-review/README.md

@@ -15,6 +15,23 @@ Target Usage
 
 Projects where policy reviews are required.
 
+Configiuration
+--------------
+
+Groups are defined in the workflow.config inside the project git. They take following options,
+
+{
+...
+ReviewGroups: [
+     {
+        "Name": "name of the group user",
+        "Reviewers": ["members", "of", "group"],
+        "Silent": (true, false) -- if true, do not explicitly require review requests of group members
+     },
+],
+...
+}
+
 Requirements
 ------------
   * Gitea token to:
@@ -22,3 +39,16 @@ Requirements
      + R/W Notification
      + R   User
 
+Env Variables
+-------------
+The following variables can be used (and override) command line parameters.
+
+  * `AUTOGITS_CONFIG` - config file location
+  * `AUTOGITS_URL` - Gitea URL
+  * `AUTOGITS_RABBITURL` - RabbitMQ url
+  * `AUTOGITS_DEBUG` - when set, debug level logging enabled
+
+Authentication env variables
+  * `GITEA_TOKEN` - Gitea user token
+  * `AMQP_USERNAME`, `AMQP_PASSWORD` - username and password for rabbitmq
+

group-review/main.go

@@ -5,12 +5,14 @@ import (
 	"fmt"
 	"log"
 	"net/url"
+	"os"
 	"regexp"
 	"runtime/debug"
 	"slices"
 	"strconv"
 	"strings"
 	"time"
+	"unicode"
 
 	"src.opensuse.org/autogits/common"
 	"src.opensuse.org/autogits/common/gitea-generated/models"
@@ -21,19 +23,32 @@ var acceptRx *regexp.Regexp
 var rejectRx *regexp.Regexp
 var groupName string
 
-func InitRegex(groupName string) {
-	acceptRx = regexp.MustCompile("\\s*:\\s*LGTM")
-	rejectRx = regexp.MustCompile("\\s*:\\s*")
+func InitRegex(newGroupName string) {
+	groupName = newGroupName
+	acceptRx = regexp.MustCompile("^:\\s*(LGTM|approved?)")
+	rejectRx = regexp.MustCompile("^:\\s*")
 }
 
 func ParseReviewLine(reviewText string) (bool, string) {
 	line := strings.TrimSpace(reviewText)
-	glen := len(groupName)
-	if len(line) < glen || line[0:glen] != groupName {
+	groupTextName := "@" + groupName
+	glen := len(groupTextName)
+	if len(line) < glen || line[0:glen] != groupTextName {
 		return false, line
 	}
 
-	return true, line[glen:]
+	l := line[glen:]
+	for idx, r := range l {
+		if unicode.IsSpace(r) {
+			continue
+		} else if r == ':' {
+			return true, l[idx:]
+		} else {
+			return false, line
+		}
+	}
+
+	return false, line
 }
 
 func ReviewAccepted(reviewText string) bool {
@@ -99,23 +114,32 @@ var commentStrings = []string{
     "change_time_estimate",
 }*/
 
-func FindAcceptableReviewInTimeline(user string, timeline []*models.TimelineComment, reviews []*models.PullReview) *models.PullReview {
-	var good_review *models.PullReview
-
+func FindAcceptableReviewInTimeline(user string, timeline []*models.TimelineComment, reviews []*models.PullReview) *models.TimelineComment {
 	for _, t := range timeline {
-		if t.Type == common.CommentType_Review && t.User != nil && t.User.UserName == user && t.Created == t.Updated {
-			for _, r := range reviews {
-				if r.ID == t.ReviewID && (ReviewAccepted(r.Body) || ReviewRejected(r.Body)) {
-					good_review = r
-					break
-				}
+		if t.Type == common.TimelineCommentType_Comment && t.User.UserName == user && t.Created == t.Updated {
+			if ReviewAccepted(t.Body) || ReviewRejected(t.Body) {
+				return t
 			}
-		} else if (t.Type == common.CommentType_DismissReview || t.Type == common.CommentType_ReviewRequested) && t.Assignee != nil && t.Assignee.UserName == user {
-			good_review = nil
 		}
 	}
 
-	return good_review
+	return nil
+}
+
+func FindOurLastReviewInTimeline(timeline []*models.TimelineComment) *models.TimelineComment {
+	for _, t := range timeline {
+		if t.Type == common.TimelineCommentType_Review && t.User.UserName == groupName && t.Created == t.Updated {
+			return t
+		}
+	}
+
+	return nil
+}
+
+func UnrequestReviews(gitea common.Gitea, org, repo string, id int64, users []string) {
+	if err := gitea.UnrequestReview(org, repo, id, users...); err != nil {
+		common.LogError("Can't remove reviewrs after a review:", err)
+	}
 }
 
 func ProcessNotifications(notification *models.NotificationThread, gitea common.Gitea) {
@@ -126,7 +150,7 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 		}
 	}()
 
-	rx := regexp.MustCompile(`^/?api/v\d+/repos/(?<org>[_a-zA-Z0-9-]+)/(?<project>[_a-zA-Z0-9-]+)/(?:issues|pulls)/(?<num>[0-9]+)$`)
+	rx := regexp.MustCompile(`^/?api/v\d+/repos/(?<org>[_\.a-zA-Z0-9-]+)/(?<project>[_\.a-zA-Z0-9-]+)/(?:issues|pulls)/(?<num>[0-9]+)$`)
 	subject := notification.Subject
 	u, err := url.Parse(notification.Subject.URL)
 	if err != nil {
@@ -144,13 +168,29 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 	repo := match[2]
 	id, _ := strconv.ParseInt(match[3], 10, 64)
 
-	common.LogInfo("processing:", fmt.Sprintf("%s/%s#%d", org, repo, id))
+	common.LogInfo("processing:", fmt.Sprintf("%s/%s!%d", org, repo, id))
 	pr, err := gitea.GetPullRequest(org, repo, id)
 	if err != nil {
 		common.LogError("  ** Cannot fetch PR associated with review:", subject.URL, "Error:", err)
 		return
 	}
 
+	if err := ProcessPR(pr); err == nil && !common.IsDryRun {
+		if err := gitea.SetNotificationRead(notification.ID); err != nil {
+			common.LogDebug("  Cannot set notification as read", err)
+		}
+	} else if err != nil && err != ReviewNotFinished {
+		common.LogError(err)
+	}
+}
+
+var ReviewNotFinished = fmt.Errorf("Review is not finished")
+
+func ProcessPR(pr *models.PullRequest) error {
+	org := pr.Base.Repo.Owner.UserName
+	repo := pr.Base.Repo.Name
+	id := pr.Index
+
 	found := false
 	for _, reviewer := range pr.RequestedReviewers {
 		if reviewer != nil && reviewer.UserName == groupName {
@@ -160,74 +200,75 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 	}
 	if !found {
 		common.LogInfo("   review is not requested for", groupName)
-		if !common.IsDryRun {
-			gitea.SetNotificationRead(notification.ID)
-		}
-		return
+		return nil
 	}
 
 	config := configs.GetPrjGitConfig(org, repo, pr.Base.Name)
+	if config == nil {
+		return fmt.Errorf("Cannot find config for: %s", pr.URL)
+	}
 	if pr.State == "closed" {
 		// dismiss the review
 		common.LogInfo("  -- closed request, so nothing to review")
-		if !common.IsDryRun {
-			gitea.SetNotificationRead(notification.ID)
-		}
-		return
+		return nil
 	}
 
 	reviews, err := gitea.GetPullRequestReviews(org, repo, id)
 	if err != nil {
-		common.LogInfo("  ** No reviews associated with request:", subject.URL, "Error:", err)
-		return
+		return fmt.Errorf("Failed to fetch reviews for: %v: %w", pr.URL, err)
 	}
 
 	timeline, err := common.FetchTimelineSinceReviewRequestOrPush(gitea, groupName, pr.Head.Sha, org, repo, id)
 	if err != nil {
-		common.LogError(err)
-		return
+		return fmt.Errorf("Failed to fetch timeline to review. %w", err)
 	}
 
-	requestReviewers, err := config.GetReviewGroupMembers(groupName)
+	groupConfig, err := config.GetReviewGroup(groupName)
 	if err != nil {
-		common.LogError(err)
-		return
+		return fmt.Errorf("Failed to fetch review group. %w", err)
 	}
 
 	// submitter cannot be reviewer
+	requestReviewers := slices.Clone(groupConfig.Reviewers)
 	requestReviewers = slices.DeleteFunc(requestReviewers, func(u string) bool { return u == pr.User.UserName })
 	//	pr.Head.Sha
 
 	for _, reviewer := range requestReviewers {
 		if review := FindAcceptableReviewInTimeline(reviewer, timeline, reviews); review != nil {
-			if review.State == common.ReviewStateApproved && ReviewAccepted(review.Body) {
+			if ReviewAccepted(review.Body) {
 				if !common.IsDryRun {
-					gitea.AddReviewComment(pr, common.ReviewStateApproved, "Signed off by: "+reviewer)
-					if !common.IsDryRun {
-						if err := gitea.SetNotificationRead(notification.ID); err != nil {
-							common.LogDebug("  Cannot set notification as read", err)
+					text := reviewer + " approved a review on behalf of " + groupName
+					if review := FindOurLastReviewInTimeline(timeline); review == nil || review.Body != text {
+						_, err := gitea.AddReviewComment(pr, common.ReviewStateApproved, text)
+						if err != nil {
+							common.LogError("    -> failed to write approval comment", err)
 						}
+						UnrequestReviews(gitea, org, repo, id, requestReviewers)
 					}
 				}
 				common.LogInfo("  -> approved by", reviewer)
-				common.LogInfo("     review at", review.Submitted)
-				return
-			} else if review.State == common.ReviewStateRequestChanges && ReviewRejected(review.Body) {
+				common.LogInfo("     review at", review.Created)
+				return nil
+			} else if ReviewRejected(review.Body) {
 				if !common.IsDryRun {
-					gitea.AddReviewComment(pr, common.ReviewStateRequestChanges, "Request changes. See review by: "+reviewer)
-					if err := gitea.SetNotificationRead(notification.ID); err != nil {
-						common.LogDebug("  Cannot set notification as read", err)
+					text := reviewer + " requested changes on behalf of " + groupName + ". See " + review.HTMLURL
+					if review := FindOurLastReviewInTimeline(timeline); review == nil || review.Body != text {
+						_, err := gitea.AddReviewComment(pr, common.ReviewStateRequestChanges, text)
+						if err != nil {
+							common.LogError("    -> failed to write rejecting comment", err)
+						}
+						UnrequestReviews(gitea, org, repo, id, requestReviewers)
 					}
 				}
 				common.LogInfo("  -> declined by", reviewer)
-				return
+				return nil
 			}
 		}
 	}
 
 	// request group member reviews, if missing
 	common.LogDebug("  Review incomplete...")
-	if len(requestReviewers) > 0 {
+	if !groupConfig.Silent && len(requestReviewers) > 0 {
 		common.LogDebug("  Requesting reviews for:", requestReviewers)
 		if !common.IsDryRun {
 			if _, err := gitea.RequestReviews(pr, requestReviewers...); err != nil {
@@ -239,10 +280,34 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 	} else {
 		common.LogDebug("  Not requesting additional reviewers")
 	}
+
+	// add a helpful comment, if not yet added
+	found_help_comment := false
+	for _, t := range timeline {
+		if t.Type == common.TimelineCommentType_Comment && t.User != nil && t.User.UserName == groupName {
+			found_help_comment = true
+			break
+		}
+	}
+
+	if !found_help_comment && !common.IsDryRun {
+		helpComment := fmt.Sprintln("Review by", groupName, "represents a group of reviewers:", strings.Join(requestReviewers, ", "), ".\n\n"+
+			"Do **not** use standard review interface to review on behalf of the group.\n"+
+			"To accept the review on behalf of the group, create the following comment: `@"+groupName+": approve`.\n"+
+			"To request changes on behalf of the group, create the following comment: `@"+groupName+": decline` followed with lines justifying the decision.\n"+
+			"Future edits of the comments are ignored, a new comment is required to change the review state.")
+		if slices.Contains(groupConfig.Reviewers, pr.User.UserName) {
+			helpComment = helpComment + "\n\n" +
+				"Submitter is member of this review group, hence they are excluded from being one of the reviewers here"
+		}
+		gitea.AddComment(pr, helpComment)
+	}
+
+	return ReviewNotFinished
 }
 
-func PeriodReviewCheck(gitea common.Gitea) {
-	notifications, err := gitea.GetPullNotifications(nil)
+func PeriodReviewCheck() {
+	notifications, err := gitea.GetNotifications(common.GiteaNotificationType_Pull, nil)
 	if err != nil {
 		common.LogError("   Error fetching unread notifications: %w", err)
 		return
@@ -250,19 +315,38 @@ func PeriodReviewCheck(gitea common.Gitea) {
 
 	for _, notification := range notifications {
 		ProcessNotifications(notification, gitea)
-
 	}
 }
 
+var gitea common.Gitea
+
 func main() {
 	giteaUrl := flag.String("gitea-url", "https://src.opensuse.org", "Gitea instance used for reviews")
 	rabbitMqHost := flag.String("rabbit-url", "amqps://rabbit.opensuse.org", "RabbitMQ instance where Gitea webhook notifications are sent")
-	interval := flag.Int64("interval", 5, "Notification polling interval in minutes (min 1 min)")
+	interval := flag.Int64("interval", 10, "Notification polling interval in minutes (min 1 min)")
 	configFile := flag.String("config", "", "PrjGit listing config file")
 	logging := flag.String("logging", "info", "Logging level: [none, error, info, debug]")
 	flag.BoolVar(&common.IsDryRun, "dry", false, "Dry run, no effect. For debugging")
 	flag.Parse()
 
+	if err := common.SetLoggingLevelFromString(*logging); err != nil {
+		common.LogError(err.Error())
+		return
+	}
+
+	if cf := os.Getenv("AUTOGITS_CONFIG"); len(cf) > 0 {
+		*configFile = cf
+	}
+	if url := os.Getenv("AUTOGITS_URL"); len(url) > 0 {
+		*giteaUrl = url
+	}
+	if url := os.Getenv("AUTOGITS_RABBITURL"); len(url) > 0 {
+		*rabbitMqHost = url
+	}
+	if debug := os.Getenv("AUTOGITS_DEBUG"); len(debug) > 0 {
+		common.SetLoggingLevel(common.LogLevelDebug)
+	}
+
 	args := flag.Args()
 	if len(args) != 1 {
 		log.Println("  syntax:")
@@ -294,7 +378,7 @@ func main() {
 		return
 	}
 
-	gitea := common.AllocateGiteaTransport(*giteaUrl)
+	gitea = common.AllocateGiteaTransport(*giteaUrl)
 	configs, err = common.ResolveWorkflowConfigs(gitea, configData)
 	if err != nil {
 		common.LogError("Cannot parse workflow configs:", err)
@@ -307,11 +391,6 @@ func main() {
 		return
 	}
 
-	if err := common.SetLoggingLevelFromString(*logging); err != nil {
-		common.LogError(err.Error())
-		return
-	}
-
 	if *interval < 1 {
 		*interval = 1
 	}
@@ -338,19 +417,22 @@ func main() {
 		config_modified: make(chan *common.AutogitConfig),
 	}
 
-	configUpdates := &common.ListenDefinitions{
-		RabbitURL: u,
-		Orgs:      []string{},
+	process_issue_pr := IssueCommentProcessor{}
+
+	configUpdates := &common.RabbitMQGiteaEventsProcessor{
+		Orgs: []string{},
 		Handlers: map[string]common.RequestProcessor{
-			common.RequestType_Push: &config_update,
+			common.RequestType_Push:         &config_update,
+			common.RequestType_IssueComment: &process_issue_pr,
 		},
 	}
+	configUpdates.Connection().RabbitURL = u
 	for _, c := range configs {
 		if org, _, _ := c.GetPrjGit(); !slices.Contains(configUpdates.Orgs, org) {
 			configUpdates.Orgs = append(configUpdates.Orgs, org)
 		}
 	}
-	go configUpdates.ProcessRabbitMQEvents()
+	go common.ProcessRabbitMQEvents(configUpdates)
 
 	for {
 	config_update_loop:
@@ -378,7 +460,7 @@ func main() {
 			}
 		}
 
-		PeriodReviewCheck(gitea)
+		PeriodReviewCheck()
 		time.Sleep(time.Duration(*interval * int64(time.Minute)))
 	}
 }

group-review/main_test.go

@@ -2,6 +2,76 @@ package main
 
 import "testing"
 
-func TestReviews(t *testing.T) {
+func TestReviewApprovalCheck(t *testing.T) {
+	tests := []struct {
+		Name      string
+		GroupName string
+		InString  string
+		Approved  bool
+		Rejected  bool
+	}{
+		{
+			Name:      "Empty String",
+			GroupName: "group",
+			InString:  "",
+		},
+		{
+			Name:      "Random Text",
+			GroupName: "group",
+			InString:  "some things LGTM",
+		},
+		{
+			Name:      "Group name with Random Text means disapproval",
+			GroupName: "group",
+			InString:  "@group: some things LGTM",
+			Rejected:  true,
+		},
+		{
+			Name:      "Bad name with Approval",
+			GroupName: "group2",
+			InString:  "@group: LGTM",
+		},
+		{
+			Name:      "Bad name with Approval",
+			GroupName: "group2",
+			InString:  "@group: LGTM",
+		},
+		{
+			Name:      "LGTM approval",
+			GroupName: "group2",
+			InString:  "@group2: LGTM",
+			Approved:  true,
+		},
+		{
+			Name:      "approval",
+			GroupName: "group2",
+			InString:  "@group2: approved",
+			Approved:  true,
+		},
+		{
+			Name:      "approval",
+			GroupName: "group2",
+			InString:  "@group2: approve",
+			Approved:  true,
+		},
+		{
+			Name:      "disapproval",
+			GroupName: "group2",
+			InString:  "@group2: disapprove",
+			Rejected:  true,
+		},
+	}
 
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			InitRegex(test.GroupName)
+
+			if r := ReviewAccepted(test.InString); r != test.Approved {
+				t.Error("ReviewAccepted() returned", r, "expecting", test.Approved)
+			}
+			if r := ReviewRejected(test.InString); r != test.Rejected {
+				t.Error("ReviewRejected() returned", r, "expecting", test.Rejected)
+			}
+		})
+	}
 }

group-review/rabbit.go

@@ -7,6 +7,25 @@ import (
 	"src.opensuse.org/autogits/common"
 )
 
+type IssueCommentProcessor struct{}
+
+func (s *IssueCommentProcessor) ProcessFunc(req *common.Request) error {
+	if req.Type != common.RequestType_IssueComment {
+		return fmt.Errorf("Unhandled, ignored request type: %s", req.Type)
+	}
+
+	data := req.Data.(*common.IssueCommentWebhookEvent)
+	org := data.Repository.Owner.Username
+	repo := data.Repository.Name
+	index := int64(data.Issue.Number)
+
+	pr, err := gitea.GetPullRequest(org, repo, index)
+	if err != nil {
+		return fmt.Errorf("Failed to fetch PullRequest from event: %s/%s!%d  Error: %w", org, repo, index, err)
+	}
+	return ProcessPR(pr)
+}
+
 type ConfigUpdatePush struct {
 	config_modified chan *common.AutogitConfig
 }

obs-forward-bot/.gitignore

@@ -0,0 +1 @@
+forward-bot

obs-forward-bot/README.md

@@ -0,0 +1,7 @@
+Purpose
+-------
+
+Forwards PR as an OBS submit request when review requested.
+Accepts a request when OBS request is accepted.
+Rejects a request when OBS request is denied.
+

obs-forward-bot/main.go

@@ -0,0 +1,293 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"regexp"
+	"runtime/debug"
+	"strconv"
+	"strings"
+	"time"
+
+	"src.opensuse.org/autogits/common"
+	"src.opensuse.org/autogits/common/gitea-generated/models"
+)
+
+var LastDevelProjectUpdate *time.Time
+
+var Git common.GitHandlerGenerator
+
+func DevelProjectForPR(pr *models.PullRequest) (*common.DevelProject, error) {
+	devels, err := common.FetchDevelProjects()
+	if err != nil {
+		common.LogError("Failed to fetch devel projects:", err)
+		return nil, err
+	}
+
+	org := pr.Head.Repo.Owner.UserName
+	pkg := pr.Head.Repo.Name
+
+	common.LogDebug("Looking for devel package", org, pkg)
+
+	for _, devel_project := range devels {
+		if devel_project.Package == pkg {
+			common.LogDebug("Fetching prject meta for", devel_project.Project)
+			meta, err := Obs.GetProjectMeta(devel_project.Project)
+			if err != nil {
+				common.LogError("Failed to fetch devel project OBS meta", err)
+				return nil, err
+			}
+
+			u, err := url.Parse(meta.ScmSync)
+			if err != nil {
+				common.LogError("Failed to parse project scm", err)
+				return nil, err
+			}
+
+			if u.Hostname() != "src.opensuse.org" || strings.TrimSuffix(u.Path[1:], ".git") != org+"/_ObsPrj" {
+				common.LogError("Invalid ScmSync format for devel project", meta.ScmSync, "Expected:", u.Path, "!=", org+"/_ObsPrj")
+				return nil, fmt.Errorf("Invalid ScmSync format for devel project %s", meta.ScmSync)
+			}
+
+			g, err := Git.CreateGitHandler(org)
+			if err != nil {
+				common.LogError("Failed to alloate git:", err)
+				return nil, err
+			}
+
+			defer g.Close()
+
+			branch := u.Fragment
+			u.Fragment = ""
+			_, err = g.GitClone(common.DefaultGitPrj, branch, u.String())
+			common.PanicOnError(err)
+			expectedSha, ok := g.GitSubmoduleCommitId(common.DefaultGitPrj, pkg, branch)
+			if !ok {
+				common.LogError("Failed to find", pkg, "in projectgit")
+				return nil, fmt.Errorf("failed to find %s in projectgit", pkg)
+			}
+
+			if expectedSha == pr.Head.Sha {
+				// found a match back to the devel project
+				return devel_project, nil
+			}
+
+			return nil, fmt.Errorf("Failed to match submission to devel project")
+		}
+	}
+
+	return nil, fmt.Errorf("Failed to find PR in a devel project. Ignoring")
+}
+
+func ProcessNotification(notification *models.NotificationThread) {
+	defer func() {
+		if r := recover(); r != nil {
+			common.LogInfo("panic cought --- recovered")
+			common.LogError(string(debug.Stack()))
+		}
+	}()
+
+	rx := regexp.MustCompile(`^/?api/v\d+/repos/(?<org>[_a-zA-Z0-9-]+)/(?<project>[_a-zA-Z0-9-]+)/(?:issues|pulls)/(?<num>[0-9]+)$`)
+	subject := notification.Subject
+	u, err := url.Parse(notification.Subject.URL)
+	if err != nil {
+		common.LogError("Invalid format of notification:", subject.URL, err)
+		return
+	}
+
+	match := rx.FindStringSubmatch(u.Path)
+	if match == nil {
+		common.LogError("** Unexpected format of notification:", subject.URL)
+		return
+	}
+
+	org := match[1]
+	repo := match[2]
+	id, _ := strconv.ParseInt(match[3], 10, 64)
+
+	common.LogInfo("processing:", fmt.Sprintf("%s/%s!%d", org, repo, id))
+	pr, err := Gitea.GetPullRequest(org, repo, id)
+	if err != nil {
+		common.LogError("  ** Cannot fetch PR associated with review:", subject.URL, "Error:", err)
+		return
+	}
+
+	repository := notification.Repository
+	repoorg := repository.Owner.UserName
+	reponame := repository.Name
+
+	if repoorg != org || reponame != repo {
+		common.LogError("  *** failed to parse org notification. Expected", repoorg, reponame)
+		return
+	}
+
+	headSha := pr.Head.Sha
+	timeline, err := common.FetchTimelineSinceLastPush(Gitea, headSha, org, repo, id)
+	if err != nil {
+		common.LogError("Failed to fetch comments:", err)
+		return
+	}
+
+	ObsSrFormat := "OBS SR#%d\n"
+	ExtractSR := func(body string) int {
+		rx := regexp.MustCompile("^OBS SR#(\\d+)$")
+		for _, line := range common.SplitLines(body) {
+			if m := rx.FindStringSubmatch(line); m != nil && len(m) == 2 {
+				id, _ := strconv.ParseInt(m[1], 10, 32)
+				return int(id)
+			}
+		}
+		return 0
+	}
+
+	common.LogDebug("notification", org, repo, id)
+	superseed := false
+	for _, timeline := range timeline {
+		if timeline.Type == common.TimelineCommentType_Comment && timeline.User.UserName == GiteaUser {
+			// check if SR comment referenced here
+			if sr := ExtractSR(timeline.Body); sr > 0 {
+				status, err := Obs.RequestStatus(sr)
+				if err != nil {
+					common.LogError("Failed to request OBS request status", err)
+					return
+				}
+
+				if superseed {
+					break
+				}
+
+				common.LogInfo("Found status:", status.State.State)
+				if !common.IsDryRun {
+					if status.State.State == common.RequestStatus_Accepted {
+						if _, err := Gitea.AddReviewComment(pr, common.ReviewStateApproved, "SR was accepted in OBS. Approving."); err != nil {
+							common.LogError("Failed to add review comment to PR:", err)
+							return
+						}
+					} else if status.State.State == common.RequestStatus_Declined || status.State.State == common.RequestStatus_Revoked {
+						if _, err := Gitea.AddReviewComment(pr, common.ReviewStateRequestChanges, "SR was rejected in OBS. Rejecting."); err != nil {
+							common.LogError("Failed to add review comment to PR:", err)
+							return
+						}
+					} else {
+						common.LogDebug("Request is in state:", status.State.State, "Waiting.")
+						return
+					}
+					Gitea.SetNotificationRead(notification.ID)
+				} else {
+				}
+				return
+			}
+		} else if timeline.Type == common.TimelineCommentType_PushPull {
+			superseed = true
+		}
+	}
+
+	// no current SR running, create one
+	dp, err := DevelProjectForPR(pr)
+	if err != nil {
+		common.LogDebug("Failed to process PR:", err)
+		return
+	}
+
+	if !common.IsDryRun {
+		meta, err := Obs.CreateSubmitRequest(dp.Project, dp.Package, ObsTarget)
+		if err != nil {
+			common.LogError("Failed to create OBS SR: ", dp.Project, dp.Package, "=>", ObsTarget, err)
+			return
+		}
+		for {
+			// make sure we leave comment here
+			err = Gitea.AddComment(pr, "Created OBS submit request to "+ObsTarget+"\n\n"+fmt.Sprintf(ObsSrFormat, meta.Id))
+			if err == nil {
+				break
+			}
+
+			common.LogError("Failed to create Gitea comment:", err)
+			common.LogInfo("Waiting 1 minute and retrying to leave comment...")
+			time.Sleep(time.Minute)
+		}
+	} else {
+		common.LogInfo("Would create a SR from", dp.Project, "/", dp.Package, "=>", ObsTarget)
+	}
+
+}
+
+func ProcessNotifications() {
+	// process PRs and issues
+	notifications, err := Gitea.GetNotifications(common.GiteaNotificationType_Pull, nil)
+	if err != nil {
+		common.LogError("Failed to get notifications.", err)
+		return
+	}
+
+	for _, notification := range notifications {
+		ProcessNotification(notification)
+
+	}
+}
+
+var GiteaUser string
+var Gitea common.Gitea
+var Obs *common.ObsClient
+
+var ObsTarget, GiteaTargetBranch, GiteaOrg string
+
+func main() {
+	GiteaHost := flag.String("gitea-host", "https://src.opensuse.org", "Gitea host")
+	ObsHost := flag.String("obs-host", "https://api.opensuse.org", "OBS instance")
+	flag.StringVar(&ObsTarget, "obs-target", "openSUSE:Factory", "")
+	flag.StringVar(&GiteaTargetBranch, "gitea-target", "factory", "")
+	flag.StringVar(&GiteaOrg, "gitea-org", "pool", "")
+	debug := flag.Bool("debug", false, "Debug logging")
+	GitRepoPath := flag.String("git-path", "", "Git repo path")
+	flag.BoolVar(&common.IsDryRun, "dry", false, "no-op operation")
+	flag.Parse()
+
+	if *debug {
+		common.SetLoggingLevel(common.LogLevelDebug)
+	}
+
+	var err error
+	if err = common.RequireGiteaSecretToken(); err != nil {
+		log.Panic(err)
+	}
+
+	if err = common.RequireObsSecretToken(); err != nil {
+		log.Panic(err)
+	}
+
+	if Obs, err = common.NewObsClient(*ObsHost); err != nil {
+		log.Panic(err)
+	}
+
+	Gitea = common.AllocateGiteaTransport(*GiteaHost)
+	if user, err := Gitea.GetCurrentUser(); err != nil {
+		log.Panic(err)
+	} else {
+		GiteaUser = user.UserName
+	}
+	common.LogInfo("Current user:", GiteaUser)
+
+	if len(*GitRepoPath) == 0 {
+		*GitRepoPath, err = os.MkdirTemp(os.TempDir(), "forward-bot")
+		if err != nil {
+			common.LogError("Failed to create tempdir:", err)
+			return
+		}
+	}
+	Git, err = common.AllocateGitWorkTree(*GitRepoPath, "bot", "nothing")
+	if err != nil {
+		common.LogError("Failed to allocate git tree", err)
+		return
+	}
+
+	for {
+		common.LogDebug("--- Starting processing notifications ---")
+		ProcessNotifications()
+		common.LogDebug("---   End processing notifications    ---")
+		time.Sleep(time.Minute * 5)
+	}
+}

obs-staging-bot/README.md

@@ -16,3 +16,27 @@ Target Usage
 
 Any project (devel, etc) that accepts PR and wants build results
 
+
+Configuration File
+------------------
+
+Bot reads `staging.config` from the project git or the PR to the project git.
+It's a JSON file with following syntax
+
+```
+{
+  "ObsProject": "home:foo:project",
+  "StagingProject": "home:foo:project:staging",
+  "QA": [
+    {
+      "Name": "ProjectBuild",
+      "Origin": "home:foo:product:images"
+    }
+  ]
+}
+```
+
+* ObsProject: (**required**) Project where the base project is built. Builds in this project will be used to compare to builds based on sources from the PR
+* StagingProject: template project that will be used as template for the staging project. Omitting this will use the ObsProject repositories to create the staging. Staging project will be created under the template, or in the bot's home directory if not specified.
+* QA: set of projects to build ontop of the binaries built in staging.
+

obs-staging-bot/main.go

@@ -47,15 +47,18 @@ const (
 	Username = "autogits_obs_staging_bot"
 )
 
-var GiteaToken string
 var runId uint
 
 func FetchPrGit(git common.Git, pr *models.PullRequest) error {
-	// clone PR head and base and return path
-	cloneURL := pr.Head.Repo.CloneURL
-	if GiteaUseSshClone {
-		cloneURL = pr.Head.Repo.SSHURL
-	}
+	// clone PR head via base (target) repo
+	cloneURL := pr.Base.Repo.CloneURL
+
+	// pass our token as user always
+	user, err := url.Parse(cloneURL)
+	common.PanicOnError(err)
+	user.User = url.User(common.GetGiteaToken())
+	cloneURL = user.String()
+
 	if _, err := os.Stat(path.Join(git.GetPath(), pr.Head.Sha)); os.IsNotExist(err) {
 		common.PanicOnError(git.GitExec("", "clone", "--depth", "1", cloneURL, pr.Head.Sha))
 		common.PanicOnError(git.GitExec(pr.Head.Sha, "fetch", "--depth", "1", "origin", pr.Head.Sha, pr.MergeBase))
@@ -120,7 +123,7 @@ func ProcessBuildStatus(project, refProject *common.BuildResultList) BuildStatus
 	// the repositories should be setup equally between the projects. We
 	// need to verify that packages that are building in `refProject` are not
 	// failing in the `project`
-	BuildResultSorter := func(a, b common.BuildResult) int {
+	BuildResultSorter := func(a, b *common.BuildResult) int {
 		if c := strings.Compare(a.Repository, b.Repository); c != 0 {
 			return c
 		}
@@ -136,7 +139,7 @@ func ProcessBuildStatus(project, refProject *common.BuildResultList) BuildStatus
 		common.LogInfo("New package. Only need some success...")
 		SomeSuccess := false
 		for i := 0; i < len(project.Result); i++ {
-			repoRes := &project.Result[i]
+			repoRes := project.Result[i]
 			repoResStatus, ok := common.ObsRepoStatusDetails[repoRes.Code]
 			if !ok {
 				common.LogDebug("cannot find code:", repoRes.Code)
@@ -205,8 +208,8 @@ func ProcessBuildStatus(project, refProject *common.BuildResultList) BuildStatus
 	return BuildStatusSummaryFailed
 }
 
-func ProcessRepoBuildStatus(results, ref []common.PackageBuildStatus) (status BuildStatusSummary, SomeSuccess bool) {
-	PackageBuildStatusSorter := func(a, b common.PackageBuildStatus) int {
+func ProcessRepoBuildStatus(results, ref []*common.PackageBuildStatus) (status BuildStatusSummary, SomeSuccess bool) {
+	PackageBuildStatusSorter := func(a, b *common.PackageBuildStatus) int {
 		return strings.Compare(a.Package, b.Package)
 	}
 
@@ -263,7 +266,7 @@ func ProcessRepoBuildStatus(results, ref []common.PackageBuildStatus) (status Bu
 	return BuildStatusSummarySuccess, SomeSuccess
 }
 
-func GenerateObsPrjMeta(git common.Git, gitea common.Gitea, pr *models.PullRequest, stagingPrj, buildPrj string) (*common.ProjectMeta, error) {
+func GenerateObsPrjMeta(git common.Git, gitea common.Gitea, pr *models.PullRequest, stagingPrj, buildPrj string, stagingMasterPrj string) (*common.ProjectMeta, error) {
 	common.LogDebug("repo content fetching ...")
 	err := FetchPrGit(git, pr)
 	if err != nil {
@@ -289,7 +292,32 @@ func GenerateObsPrjMeta(git common.Git, gitea common.Gitea, pr *models.PullReque
 		}
 	}
 
-	meta, err := ObsClient.GetProjectMeta(buildPrj)
+	// find modified directories and assume they are packages
+	// TODO: use _manifest for this here
+	headDirectories, err := git.GitDirectoryList(dir, pr.Head.Sha)
+	if err != nil {
+		return nil, err
+	}
+	baseDirectories, err := git.GitDirectoryList(dir, pr.MergeBase)
+	if err != nil {
+		return nil, err
+	}
+
+	for pkg, headOid := range headDirectories {
+		if baseOid, exists := baseDirectories[pkg]; !exists || baseOid != headOid {
+			modifiedOrNew = append(modifiedOrNew, pkg)
+		}
+	}
+
+	common.LogDebug("Trying first staging master project: ", stagingMasterPrj)
+	meta, err := ObsClient.GetProjectMeta(stagingMasterPrj)
+	if err == nil {
+		// success, so we use that staging master project as our build project
+		buildPrj = stagingMasterPrj
+	} else {
+		common.LogInfo("error fetching project meta for ", stagingMasterPrj, ". Fall Back to ", buildPrj)
+		meta, err = ObsClient.GetProjectMeta(buildPrj)
+	}
 	if err != nil {
 		common.LogError("error fetching project meta for", buildPrj, ". Err:", err)
 		return nil, err
@@ -314,11 +342,13 @@ func GenerateObsPrjMeta(git common.Git, gitea common.Gitea, pr *models.PullReque
 		urlPkg = append(urlPkg, "onlybuild="+url.QueryEscape(pkg))
 	}
 	meta.ScmSync = pr.Head.Repo.CloneURL + "?" + strings.Join(urlPkg, "&") + "#" + pr.Head.Sha
+	if len(meta.ScmSync) >= 65535 {
+		return nil, errors.New("Reached max amount of package changes per request")
+	}
 	meta.Title = fmt.Sprintf("PR#%d to %s", pr.Index, pr.Base.Name)
-	meta.PublicFlags = common.Flags{Contents: "<disable/>"}
 
-	meta.Groups = nil
-	meta.Persons = nil
+	// Untouched content are flags and involved users. These can be configured
+	// via the staging project.
 
 	// set paths to parent project
 	for idx, r := range meta.Repositories {
@@ -356,6 +386,28 @@ func CreateQASubProject(stagingConfig *common.StagingConfig, git common.Git, git
 	}
 	// patch baseMeta to become the new project
 	templateMeta.Name = stagingProject + ":" + subProjectName
+	// freeze tag for now
+	if len(templateMeta.ScmSync) > 0 {
+                repository, err := url.Parse(templateMeta.ScmSync)
+                if err != nil {
+                    panic(err)
+                }
+
+		common.LogDebug("getting data for ", repository.EscapedPath())
+		split := strings.Split(repository.EscapedPath(), "/")
+		org, repo := split[1], split[2]
+
+		common.LogDebug("getting commit for ", org, " repo ", repo, " fragment ", repository.Fragment)
+		branch, err := gitea.GetCommit(org, repo, repository.Fragment)
+                if err != nil {
+                    panic(err)
+                }
+
+		// set expanded commit url
+		repository.Fragment  = branch.SHA
+		templateMeta.ScmSync = repository.String()
+		common.LogDebug("Setting scmsync url to ", templateMeta.ScmSync)
+        }
 	// Cleanup ReleaseTarget and modify affected path entries
 	for idx, r := range templateMeta.Repositories {
 		templateMeta.Repositories[idx].ReleaseTargets = nil
@@ -412,7 +464,8 @@ func StartOrUpdateBuild(config *common.StagingConfig, git common.Git, gitea comm
 	var state RequestModification = RequestModificationSourceChanged
 	if meta == nil {
 		// new build
-		meta, err = GenerateObsPrjMeta(git, gitea, pr, obsPrProject, config.ObsProject)
+		common.LogDebug(" Staging master:", config.StagingProject)
+		meta, err = GenerateObsPrjMeta(git, gitea, pr, obsPrProject, config.ObsProject, config.StagingProject)
 		if err != nil {
 			return RequestModificationNoChange, err
 		}
@@ -426,6 +479,8 @@ func StartOrUpdateBuild(config *common.StagingConfig, git common.Git, gitea comm
 	} else {
 		err = ObsClient.SetProjectMeta(meta)
 		if err != nil {
+			x, _ := xml.MarshalIndent(meta, "", "   ")
+			common.LogDebug(" meta:", string(x))
 			common.LogError("cannot create meta project:", err)
 			return RequestModificationNoChange, err
 		}
@@ -459,7 +514,7 @@ func FetchOurLatestActionableReview(gitea common.Gitea, org, repo string, id int
 
 	for idx := len(reviews) - 1; idx >= 0; idx-- {
 		review := reviews[idx]
-		if review.User != nil || review.User.UserName == Username {
+		if review.User == nil || review.User.UserName == Username {
 			if IsDryRun {
 				// for purposes of moving forward a no-op check
 				return review, nil
@@ -547,7 +602,7 @@ func CleanupPullNotification(gitea common.Gitea, thread *models.NotificationThre
 	}
 
 	if pr.State != "closed" {
-		common.LogInfo("   ignoring peding PR", thread.Subject.HTMLURL, " state:", pr.State)
+		common.LogInfo("   ignoring pending PR", thread.Subject.HTMLURL, " state:", pr.State)
 		return false
 	}
 
@@ -582,7 +637,7 @@ func CleanupPullNotification(gitea common.Gitea, thread *models.NotificationThre
 	}
 
 	if !pr.HasMerged && time.Since(time.Time(pr.Closed)) < time.Duration(config.CleanupDelay)*time.Hour {
-		common.LogInfo("Cooldown period for cleanup of", thread.URL)
+		common.LogInfo("Cooldown period for cleanup of", thread.Subject.HTMLURL)
 		return false
 	}
 
@@ -620,6 +675,14 @@ func CleanupPullNotification(gitea common.Gitea, thread *models.NotificationThre
 	return false // cleaned up now, but the cleanup was not aleady done
 }
 
+func SetStatus(gitea common.Gitea, org, repo, hash string, status *models.CommitStatus) error {
+	_, err := gitea.SetCommitStatus(org, repo, hash, status)
+	if err != nil {
+		common.LogError(err)
+	}
+	return err
+}
+
 func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, error) {
 	dir, err := os.MkdirTemp(os.TempDir(), BotName)
 	common.PanicOnError(err)
@@ -682,6 +745,7 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 		stagingConfig, err := common.ParseStagingConfig(data)
 		if err != nil {
 			common.LogError("Error parsing config file", common.StagingConfigFile, err)
+			return true, err
 		}
 
 		if stagingConfig.ObsProject == "" {
@@ -694,7 +758,7 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 		}
 
 		meta, err := ObsClient.GetProjectMeta(stagingConfig.ObsProject)
-		if err != nil {
+		if err != nil || meta == nil {
 			common.LogError("Cannot find reference project meta:", stagingConfig.ObsProject, err)
 			if !IsDryRun {
 				_, err := gitea.AddReviewComment(pr, common.ReviewStateRequestChanges, "Cannot fetch reference project meta")
@@ -755,23 +819,28 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 		common.LogDebug(" # head submodules:", len(headSubmodules))
 		common.LogDebug(" # base submodules:", len(baseSubmodules))
 
-		modifiedOrNew := make([]string, 0, 16)
+		modifiedPackages := make([]string, 0, 16)
+		newPackages := make([]string, 0, 16)
 		if !stagingConfig.RebuildAll {
 			for pkg, headOid := range headSubmodules {
 				if baseOid, exists := baseSubmodules[pkg]; !exists || baseOid != headOid {
-					modifiedOrNew = append(modifiedOrNew, pkg)
+					if exists {
+						modifiedPackages = append(modifiedPackages, pkg)
+					} else {
+						newPackages = append(newPackages, pkg)
+					}
 					common.LogDebug(pkg, ":", baseOid, "->", headOid)
 				}
 			}
 		}
 
-		if len(modifiedOrNew) == 0 {
+		if len(modifiedPackages) == 0 && len(newPackages) == 0 {
 			rebuild_all := false || stagingConfig.RebuildAll
 
 			reviews, err := gitea.GetPullRequestReviews(pr.Base.Repo.Owner.UserName, pr.Base.Repo.Name, pr.Index)
 			common.LogDebug("num reviews:", len(reviews))
 			if err == nil {
-				rebuild_rx := regexp.MustCompile("^@autogits_obs_staging_bot\\s*:\\s*(re)?build\\s*all$")
+				rebuild_rx := regexp.MustCompile("^@autogits_obs_staging_bot\\s*:?\\s*(re)?build\\s*all$")
 			done:
 				for _, r := range reviews {
 					for _, l := range common.SplitLines(r.Body) {
@@ -803,7 +872,12 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 			if !rebuild_all {
 				common.LogInfo("No package changes detected. Ignoring")
 				if !IsDryRun {
-					_, err = gitea.AddReviewComment(pr, common.ReviewStateComment, "No package changes. Not rebuilding project by default")
+					_, err := gitea.AddReviewComment(pr, common.ReviewStateApproved, "No package changes, not rebuilding project by default, accepting change")
+					if err != nil {
+						common.LogError(err)
+					} else {
+						return true, nil
+					}
 				}
 				return true, err
 			}
@@ -819,6 +893,22 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 			TargetURL:   ObsWebHost + "/project/show/" + stagingProject,
 		}
 
+		if err != nil {
+			msg := "Unable to setup stage project " + stagingConfig.ObsProject
+			status.Status = common.CommitStatus_Fail
+			common.LogError(msg)
+			if !IsDryRun {
+				SetStatus(gitea, org, repo, pr.Head.Sha, status)
+				_, err = gitea.AddReviewComment(pr, common.ReviewStateRequestChanges, msg)
+				if err != nil {
+					common.LogError(err)
+				} else {
+					return true, nil
+				}
+			}
+			return false, nil
+		}
+
 		msg := "Changed source updated for build"
 		if change == RequestModificationProjectCreated {
 			msg = "Build is started in " + ObsWebHost + "/project/show/" +
@@ -827,8 +917,7 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 			if len(stagingConfig.QA) > 0 {
 				msg = msg + "\nAdditional QA builds: \n"
 			}
-			gitea.SetCommitStatus(pr.Base.Repo.Owner.UserName, pr.Base.Repo.Name, pr.Head.Sha, status)
-
+			SetStatus(gitea, org, repo, pr.Head.Sha, status)
 			for _, setup := range stagingConfig.QA {
 				CreateQASubProject(stagingConfig, git, gitea, pr,
 					stagingProject,
@@ -842,42 +931,44 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 			gitea.AddComment(pr, msg)
 		}
 
-		baseResult, err := ObsClient.LastBuildResults(stagingConfig.ObsProject, modifiedOrNew...)
+		baseResult, err := ObsClient.LastBuildResults(stagingConfig.ObsProject, modifiedPackages...)
 		if err != nil {
 			common.LogError("failed fetching ref project status for", stagingConfig.ObsProject, ":", err)
 		}
 		stagingResult, err := ObsClient.BuildStatus(stagingProject)
 		if err != nil {
-			common.LogError("failed fetching ref project status for", stagingProject, ":", err)
+			common.LogError("failed fetching stage project status for", stagingProject, ":", err)
 		}
 		buildStatus := ProcessBuildStatus(stagingResult, baseResult)
 
+		done := false
 		switch buildStatus {
 		case BuildStatusSummarySuccess:
 			status.Status = common.CommitStatus_Success
+			done = true
 			if !IsDryRun {
 				_, err := gitea.AddReviewComment(pr, common.ReviewStateApproved, "Build successful")
 				if err != nil {
 					common.LogError(err)
-				} else {
-					return true, nil
 				}
 			}
 		case BuildStatusSummaryFailed:
 			status.Status = common.CommitStatus_Fail
+			done = true
 			if !IsDryRun {
 				_, err := gitea.AddReviewComment(pr, common.ReviewStateRequestChanges, "Build failed")
 				if err != nil {
 					common.LogError(err)
-				} else {
-					return true, nil
 				}
 			}
 		}
 		common.LogInfo("Build status:", buildStatus)
-		gitea.SetCommitStatus(pr.Base.Repo.Owner.UserName, pr.Base.Repo.Name, pr.Head.Sha, status)
-
-		// waiting for build results -- nothing to do
+		if !IsDryRun {
+			if err = SetStatus(gitea, org, repo, pr.Head.Sha, status); err != nil {
+				return false, err
+			}
+		}
+		return done, nil
 
 	} else if err == NonActionableReviewError || err == NoReviewsFoundError {
 		return true, nil
@@ -888,7 +979,7 @@ func ProcessPullRequest(gitea common.Gitea, org, repo string, id int64) (bool, e
 
 func PollWorkNotifications(giteaUrl string) {
 	gitea := common.AllocateGiteaTransport(giteaUrl)
-	data, err := gitea.GetPullNotifications(nil)
+	data, err := gitea.GetNotifications(common.GiteaNotificationType_Pull, nil)
 
 	if err != nil {
 		common.LogError(err)
@@ -918,7 +1009,7 @@ func PollWorkNotifications(giteaUrl string) {
 	cleanupFinished := false
 	for page := int64(1); !cleanupFinished; page++ {
 		cleanupFinished = true
-		if data, err := gitea.GetDonePullNotifications(page); data != nil {
+		if data, err := gitea.GetDoneNotifications(common.GiteaNotificationType_Pull, page); data != nil {
 			for _, n := range data {
 				if n.Unread {
 					common.LogError("Done notification is unread or pinned?", *n.Subject)
@@ -936,7 +1027,6 @@ func PollWorkNotifications(giteaUrl string) {
 
 var ListPullNotificationsOnly bool
 var GiteaUrl string
-var GiteaUseSshClone bool
 var ObsWebHost string
 var IsDryRun bool
 var ProcessPROnly string
@@ -960,7 +1050,6 @@ func main() {
 	ProcessPROnly := flag.String("pr", "", "Process only specific PR and ignore the rest. Use for debugging")
 	buildRoot := flag.String("build-root", "", "Default build location for staging projects. Default is bot's home project")
 	flag.StringVar(&GiteaUrl, "gitea-url", "https://src.opensuse.org", "Gitea instance")
-	flag.BoolVar(&GiteaUseSshClone, "use-ssh-clone", false, "enforce cloning via ssh")
 	obsApiHost := flag.String("obs", "https://api.opensuse.org", "API for OBS instance")
 	flag.StringVar(&ObsWebHost, "obs-web", "", "Web OBS instance, if not derived from the obs config")
 	flag.BoolVar(&IsDryRun, "dry", false, "Dry-run, don't actually create any build projects or review changes")
@@ -977,6 +1066,7 @@ func main() {
 		ObsWebHost = ObsWebHostFromApiHost(*obsApiHost)
 	}
 
+	common.LogDebug("OBS Gitea Host:", GiteaUrl)
 	common.LogDebug("OBS Web Host:", ObsWebHost)
 	common.LogDebug("OBS API Host:", *obsApiHost)
 
@@ -994,7 +1084,7 @@ func main() {
 	}
 
 	if len(*ProcessPROnly) > 0 {
-		rx := regexp.MustCompile("^(\\w+)/(\\w+)#(\\d+)$")
+		rx := regexp.MustCompile("^([^/#]+)/([^/#]+)#([0-9]+)$")
 		m := rx.FindStringSubmatch(*ProcessPROnly)
 		if m == nil {
 			common.LogError("Cannot find any PR matches in", *ProcessPROnly)

obs-status-service/.gitignore

@@ -1 +1,2 @@
 obs-status-service
+*.svg

obs-status-service/README.md

@@ -1,25 +1,60 @@
 OBS Status Service
 ==================
 
-Reports build status of OBS service as an easily to produce SVG
+Reports build status of OBS service as an easily to produce SVG. Repository
+results (build results) are cached for 10 seconds and repository listing
+for OBS instance are cached for 5 minutes -- new repositories take up to
+5 minutes to be visible.
 
 Requests for individual build results:
-     /obs:project/package/repo/arch
+
+     /status/obs:project/package/repo/arch
+
+where `repo` and `arch` are optional parameters.
+
 Requests for project results
-     /obs:project
+
+     /status/obs:project
+
+Get requests for / will also return 404 statu normally. If the Backend redis
+server is not available, it will return 500
+
+
+By default, SVG output is generated, suitable for inclusion. But JSON and XML
+output is possible by setting `Accept:` request header
+
+| Accept Request Header  |  Output format
+|------------------------|---------------------
+|                        |  SVG image
+| application/json       |  JSON data
+| application/obs+xml    |  XML output
 
 
 Areas of Responsibility
 -----------------------
 
-  * Monitors RabbitMQ interface for notification of OBS package and project status
-  * Produces SVG output based on GET request
-  * Cache results (sqlite) and periodically update results from OBS (in case of messages are missing)
+  * Fetch and cache internal data from OBS and present it in usable format:
+    + Generate SVG output for specific OBS project or package
+    + Generate JSON/XML output for automated processing
+  * Low-overhead
 
 
 Target Usage
 ------------
 
-  * README.md of package git or project git
+  * inside README.md of package git or project git
   * comment section of a Gitea PR
+  * automated build result processing
 
+Running
+-------
+
+Default parameters can be changed by env variables
+
+| Environment variable            | Default                     | Description
+|---------------------------------|-----------------------------|------------
+| `OBS_STATUS_SERVICE_OBS_URL`    | https://build.opensuse.org  | Location for creating build logs and monitor page build results
+| `OBS_STATUS_SERVICE_LISTEN`     | [::1]:8080                  | Listening address and port
+| `OBS_STATUS_SERVICE_CERT`       | /run/obs-status-service.pem | Location of certificate file for service
+| `OBS_STATUS_SERVICE_KEY`        | /run/obs-status-service.pem | Location of key file for service
+| `REDIS`                         |                             | OBS's Redis instance URL

obs-status-service/main.go

@@ -19,11 +19,20 @@ package main
  */
 
 import (
-	"bytes"
+	"encoding/json"
+	"encoding/xml"
 	"flag"
 	"fmt"
+	"html"
+	"io"
 	"log"
+	"maps"
 	"net/http"
+	"net/url"
+	"os"
+	"slices"
+	"strings"
+	"time"
 
 	"src.opensuse.org/autogits/common"
 )
@@ -33,52 +42,131 @@ const (
 )
 
 var obs *common.ObsClient
-var debug bool
 
-func LogDebug(v ...any) {
-	if debug {
-		log.Println(v...)
-	}
+type RepoBuildCounters struct {
+	Repository, Arch   string
+	Status             string
+	BuildStatusCounter map[string]int
 }
 
-func ProjectStatusSummarySvg(project string) []byte {
-	res := GetCurrentStatus(project)
-	if res == nil {
+func ProjectStatusSummarySvg(res []*common.BuildResult) []byte {
+	if len(res) == 0 {
 		return nil
 	}
 
-	pkgs := res.GetPackageList()
+	list := common.BuildResultList{
+		Result: res,
+	}
+	package_names := list.GetPackageList()
 	maxLen := 0
-	for _, p := range pkgs {
+	for _, p := range package_names {
 		maxLen = max(maxLen, len(p))
 	}
 
-	width := float32(len(res.Result))*1.5 + float32(maxLen)*0.8
-	height := 1.5*float32(maxLen) + 30
+	//	width := float32(len(list.Result))*1.5 + float32(maxLen)*0.8
+	//	height := 1.5*float32(maxLen) + 30
+	ret := NewSvg(SvgType_Project)
 
-	ret := bytes.Buffer{}
-	ret.WriteString(`<svg version="2.0" width="`)
-	ret.WriteString(fmt.Sprint(width))
-	ret.WriteString(`em" height="`)
-	ret.WriteString(fmt.Sprint(height))
-	ret.WriteString(`em" xmlns="http://www.w3.org/2000/svg">`)
-	ret.WriteString(`<defs>
-<g id="f"> <!-- failed -->
-  <rect width="1em" height="1em" fill="#800" />
-</g>
-<g id="s"> <!--succeeded-->
-  <rect width="1em" height="1em" fill="#080" />
-</g>
-<g id="buidling"> <!--building-->
-  <rect width="1em" height="1em" fill="#880" />
-</g>
-</defs>`)
-	ret.WriteString(`<use href="#f" x="1em" y="2em"/>`)
-	ret.WriteString(`</svg>`)
-	return ret.Bytes()
+	status := make([]RepoBuildCounters, len(res))
+
+	for i, repo := range res {
+		status[i].Arch = repo.Arch
+		status[i].Repository = repo.Repository
+		status[i].Status = repo.Code
+		status[i].BuildStatusCounter = make(map[string]int)
+
+		for _, pkg := range repo.Status {
+			status[i].BuildStatusCounter[pkg.Code]++
+		}
+	}
+	slices.SortFunc(status, func(a, b RepoBuildCounters) int {
+		if r := strings.Compare(a.Repository, b.Repository); r != 0 {
+			return r
+		}
+		return strings.Compare(a.Arch, b.Arch)
+	})
+	repoName := ""
+	ret.ypos = 3.0
+	for _, repo := range status {
+		if repo.Repository != repoName {
+			repoName = repo.Repository
+			ret.WriteTitle(repoName)
+		}
+
+		ret.WriteSubtitle(repo.Arch)
+		statuses := slices.Sorted(maps.Keys(repo.BuildStatusCounter))
+		for _, status := range statuses {
+			ret.WriteProjectStatus(res[0].Project, repo.Repository, repo.Arch, status, repo.BuildStatusCounter[status])
+		}
+	}
+
+	return ret.GenerateSvg()
 }
 
-func PackageStatusSummarySvg(status common.PackageBuildStatus) []byte {
+func LinkToBuildlog(R *common.BuildResult, S *common.PackageBuildStatus) string {
+	if R != nil && S != nil {
+		switch S.Code {
+		case "succeeded", "failed", "building":
+			return "/buildlog/" + url.PathEscape(R.Project) + "/" + url.PathEscape(S.Package) + "/" + url.PathEscape(R.Repository) + "/" + url.PathEscape(R.Arch)
+		}
+	}
+	return ""
+}
+
+func DeleteExceptPkg(pkg string) func(*common.PackageBuildStatus) bool {
+	return func(item *common.PackageBuildStatus) bool {
+		multibuild_prefix := pkg + ":"
+		return item.Package != pkg && !strings.HasPrefix(item.Package, multibuild_prefix)
+	}
+}
+
+func PackageStatusSummarySvg(pkg string, res []*common.BuildResult) []byte {
+	// per repo, per arch status bins
+	repo_names := []string{}
+	package_names := []string{}
+	multibuild_prefix := pkg + ":"
+	for _, r := range res {
+		if pos, found := slices.BinarySearchFunc(repo_names, r.Repository, strings.Compare); !found {
+			repo_names = slices.Insert(repo_names, pos, r.Repository)
+		}
+
+		for _, p := range r.Status {
+			if p.Package == pkg || strings.HasPrefix(p.Package, multibuild_prefix) {
+				if pos, found := slices.BinarySearchFunc(package_names, p.Package, strings.Compare); !found {
+					package_names = slices.Insert(package_names, pos, p.Package)
+				}
+			}
+		}
+	}
+
+	ret := NewSvg(SvgType_Package)
+	for _, pkg = range package_names {
+		//		if len(package_names) > 1 {
+		ret.WriteTitle(pkg)
+		//		}
+
+		for _, name := range repo_names {
+			ret.WriteSubtitle(name)
+			// print all repo arches here and build results
+			for _, r := range res {
+				if r.Repository != name {
+					continue
+				}
+
+				for _, s := range r.Status {
+					if s.Package == pkg {
+						link := LinkToBuildlog(r, s)
+						ret.WritePackageStatus(link, r.Arch, s.Code, s.Details)
+					}
+				}
+			}
+		}
+	}
+
+	return ret.GenerateSvg()
+}
+
+func BuildStatusSvg(repo *common.BuildResult, status *common.PackageBuildStatus) []byte {
 	buildStatus, ok := common.ObsBuildStatusDetails[status.Code]
 	if !ok {
 		buildStatus = common.ObsBuildStatusDetails["error"]
@@ -95,73 +183,256 @@ func PackageStatusSummarySvg(status common.PackageBuildStatus) []byte {
 		}
 	}
 
-	log.Println(status, " -> ", buildStatus)
+	buildlog := LinkToBuildlog(repo, status)
+	startTag := ""
+	endTag := ""
 
-	return []byte(`<svg version="2.0" width="8em" height="1.5em" xmlns="http://www.w3.org/2000/svg">
-  <rect width="100%" height="100%" fill="` + fillColor + `"/>
-  <text x="4em" y="1.1em" text-anchor="middle" fill="` + textColor + `">` + buildStatus.Code + `</text>
-</svg>`)
-}
-
-func main() {
-	cert := flag.String("cert-file", "", "TLS certificates file")
-	key := flag.String("key-file", "", "Private key for the TLS certificate")
-	listen := flag.String("listen", "[::1]:8080", "Listening string")
-	disableTls := flag.Bool("no-tls", false, "Disable TLS")
-	obsHost := flag.String("obs-host", "api.opensuse.org", "OBS API endpoint for package status information")
-	flag.BoolVar(&debug, "debug", false, "Enable debug logging")
-	flag.Parse()
-
-	common.PanicOnError(common.RequireObsSecretToken())
-
-	var err error
-	if obs, err = common.NewObsClient(*obsHost); err != nil {
-		log.Fatal(err)
+	if len(buildlog) > 0 {
+		startTag = "<a href=\"" + buildlog + "\">"
+		endTag = "</a>"
 	}
 
-	http.HandleFunc("GET /{Project}", func(res http.ResponseWriter, req *http.Request) {
-		res.WriteHeader(http.StatusBadRequest)
-	})
-	http.HandleFunc("GET /{Project}/{Package}", func(res http.ResponseWriter, req *http.Request) {
-		/*
-			obsPrj := req.PathValue("Project")
-			obsPkg := req.PathValue("Package")
+	return []byte(`<svg version="2.0" width="8em" height="1.5em" xmlns="http://www.w3.org/2000/svg">` +
+		`<rect width="100%" height="100%" fill="` + fillColor + `"/>` + startTag +
+		`<text x="4em" y="1.1em" text-anchor="middle" fill="` + textColor + `">` + html.EscapeString(buildStatus.Code) + `</text>` + endTag + `</svg>`)
+}
 
-			status, _ := PackageBuildStatus(obsPrj, obsPkg)
-			svg := PackageStatusSummarySvg(status)
-		*/
+func WriteJson(data any, res http.ResponseWriter) {
+	if jsonArray, err := json.MarshalIndent(data, "", "   "); err != nil {
+		res.WriteHeader(500)
+	} else {
+		res.Header().Add("size", fmt.Sprint(len(jsonArray)))
+		res.Write(jsonArray)
+	}
+}
 
-		res.Header().Add("content-type", "image/svg+xml")
-		//res.Header().Add("size", fmt.Sprint(len(svg)))
-		//res.Write(svg)
+func WriteXml(data any, res http.ResponseWriter) {
+	if xmlData, err := xml.MarshalIndent(data, "", "   "); err != nil {
+		res.WriteHeader(500)
+	} else {
+		res.Header().Add("size", fmt.Sprint(len(xmlData)))
+		res.Write([]byte("<resultlist>"))
+		res.Write(xmlData)
+		res.Write([]byte("</resultlist>"))
+	}
+}
+
+var ObsUrl *string
+
+func main() {
+	obsUrlDef := os.Getenv("OBS_STATUS_SERVICE_OBS_URL")
+	if len(obsUrlDef) == 0 {
+		obsUrlDef = "https://build.opensuse.org"
+	}
+	listenDef := os.Getenv("OBS_STATUS_SERVICE_LISTEN")
+	if len(listenDef) == 0 {
+		listenDef = "[::1]:8080"
+	}
+	certDef := os.Getenv("OBS_STATUS_SERVICE_CERT")
+	if len(certDef) == 0 {
+		certDef = "/run/obs-status-service.pem"
+	}
+	keyDef := os.Getenv("OBS_STATUS_SERVICE_KEY")
+	if len(keyDef) == 0 {
+		keyDef = certDef
+	}
+
+	cert := flag.String("cert-file", certDef, "TLS certificates file")
+	key := flag.String("key-file", keyDef, "Private key for the TLS certificate")
+	listen := flag.String("listen", listenDef, "Listening string")
+	disableTls := flag.Bool("no-tls", false, "Disable TLS")
+	ObsUrl = flag.String("obs-url", obsUrlDef, "OBS API endpoint for package buildlog information")
+	debug := flag.Bool("debug", false, "Enable debug logging")
+	flag.Parse()
+
+	if *debug {
+		common.SetLoggingLevel(common.LogLevelDebug)
+	}
+
+	if redisUrl := os.Getenv("REDIS"); len(redisUrl) > 0 {
+		RedisConnect(redisUrl)
+	} else {
+		common.LogError("REDIS needs to contains URL of the OBS Redis instance with login information")
+		return
+	}
+
+	var rescanRepoError error
+	go func() {
+		for {
+			if rescanRepoError = RescanRepositories(); rescanRepoError != nil {
+				common.LogError("Failed to rescan repositories.", rescanRepoError)
+			}
+			time.Sleep(time.Minute * 5)
+		}
+	}()
+
+	http.HandleFunc("GET /", func(res http.ResponseWriter, req *http.Request) {
+		if rescanRepoError != nil {
+			res.WriteHeader(500)
+			return
+		}
+		res.WriteHeader(404)
+		res.Write([]byte("404 page not found\n"))
 	})
-	http.HandleFunc("GET /{Project}/{Package}/{Repository}/{Arch}", func(res http.ResponseWriter, req *http.Request) {
+	http.HandleFunc("GET /status/{Project}", func(res http.ResponseWriter, req *http.Request) {
+		mime := ParseMimeHeader(req)
+		obsPrj := req.PathValue("Project")
+		common.LogInfo("  GET /status/"+obsPrj, "["+mime.MimeType()+"]")
+
+		status := FindAndUpdateProjectResults(obsPrj)
+		if len(status) == 0 {
+			res.WriteHeader(404)
+			return
+		}
+		res.Header().Add("content-type", mime.MimeHeader)
+		if mime.IsSvg() {
+			svg := ProjectStatusSummarySvg(status)
+			res.Header().Add("size", fmt.Sprint(len(svg)))
+			res.Write(svg)
+		} else if mime.IsJson() {
+			WriteJson(status, res)
+		} else if mime.IsXml() {
+			WriteXml(status, res)
+		}
+	})
+	http.HandleFunc("GET /status/{Project}/{Package}", func(res http.ResponseWriter, req *http.Request) {
+		mime := ParseMimeHeader(req)
+		obsPrj := req.PathValue("Project")
+		obsPkg := req.PathValue("Package")
+		common.LogInfo("  GET /status/"+obsPrj+"/"+obsPkg, "["+mime.MimeType()+"]")
+
+		status := slices.Clone(FindAndUpdateProjectResults(obsPrj))
+		for i, s := range status {
+			f := *s
+			f.Status = slices.DeleteFunc(slices.Clone(s.Status), DeleteExceptPkg(obsPkg))
+			status[i] = &f
+		}
+		if len(status) == 0 {
+			res.WriteHeader(404)
+			return
+		}
+
+		res.Header().Add("content-type", mime.MimeHeader)
+		if mime.IsSvg() {
+			svg := PackageStatusSummarySvg(obsPkg, status)
+
+			res.Header().Add("size", fmt.Sprint(len(svg)))
+			res.Write(svg)
+		} else if mime.IsJson() {
+			WriteJson(status, res)
+		} else if mime.IsXml() {
+			WriteXml(status, res)
+		}
+
+	})
+	http.HandleFunc("GET /status/{Project}/{Package}/{Repository}", func(res http.ResponseWriter, req *http.Request) {
+		mime := ParseMimeHeader(req)
+		obsPrj := req.PathValue("Project")
+		obsPkg := req.PathValue("Package")
+		repo := req.PathValue("Repository")
+		common.LogInfo("  GET /status/"+obsPrj+"/"+obsPkg, "["+mime.MimeType()+"]")
+
+		status := slices.Clone(FindAndUpdateRepoResults(obsPrj, repo))
+		for i, s := range status {
+			f := *s
+			f.Status = slices.DeleteFunc(slices.Clone(s.Status), DeleteExceptPkg(obsPkg))
+			status[i] = &f
+		}
+		if len(status) == 0 {
+			res.WriteHeader(404)
+			return
+		}
+
+		if mime.IsSvg() {
+			svg := PackageStatusSummarySvg(obsPkg, status)
+			res.Header().Add("content-type", mime.MimeHeader)
+			res.Header().Add("size", fmt.Sprint(len(svg)))
+			res.Write(svg)
+		} else if mime.IsJson() {
+			WriteJson(status, res)
+		} else if mime.IsXml() {
+			WriteXml(status, res)
+		}
+	})
+	http.HandleFunc("GET /status/{Project}/{Package}/{Repository}/{Arch}", func(res http.ResponseWriter, req *http.Request) {
+		mime := ParseMimeHeader(req)
+		prj := req.PathValue("Project")
+		pkg := req.PathValue("Package")
+		repo := req.PathValue("Repository")
+		arch := req.PathValue("Arch")
+		common.LogInfo("  GET /status/"+prj+"/"+pkg+"/"+repo+"/"+arch, "["+mime.MimeType()+"]")
+
+		res.Header().Add("content-type", mime.MimeHeader)
+		for _, r := range FindAndUpdateRepoResults(prj, repo) {
+			if r.Arch == arch {
+				if idx, found := slices.BinarySearchFunc(r.Status, &common.PackageBuildStatus{Package: pkg}, common.PackageBuildStatusComp); found {
+					status := r.Status[idx]
+					if mime.IsSvg() {
+						res.Write(BuildStatusSvg(r, status))
+					} else if mime.IsJson() {
+						WriteJson(status, res)
+					} else if mime.IsXml() {
+						WriteXml(status, res)
+					}
+					return
+				}
+				break
+			}
+		}
+
+		if mime.IsSvg() {
+			res.Write(BuildStatusSvg(nil, &common.PackageBuildStatus{Package: pkg, Code: "unknown"}))
+		}
+	})
+	http.HandleFunc("GET /search", func(res http.ResponseWriter, req *http.Request) {
+		common.LogInfo("GET /search?" + req.URL.RawQuery)
+		queries := req.URL.Query()
+		if !queries.Has("q") {
+			res.WriteHeader(400)
+			return
+		}
+
+		names := queries["q"]
+		if len(names) != 1 {
+			res.WriteHeader(400)
+			return
+		}
+
+		packages := FindPackages(names[0])
+		data, err := json.MarshalIndent(packages, "", "   ")
+		if err != nil {
+			res.WriteHeader(500)
+			common.LogError("Error in marshalling data.", err)
+			return
+		}
+
+		res.Write(data)
+		res.Header().Add("content-type", "application/json")
+		res.WriteHeader(200)
+	})
+
+	http.HandleFunc("GET /buildlog/{Project}/{Package}/{Repository}/{Arch}", func(res http.ResponseWriter, req *http.Request) {
 		prj := req.PathValue("Project")
 		pkg := req.PathValue("Package")
 		repo := req.PathValue("Repository")
 		arch := req.PathValue("Arch")
 
-		res.Header().Add("content-type", "image/svg+xml")
+		res.Header().Add("location", *ObsUrl+"/package/live_build_log/"+url.PathEscape(prj)+"/"+url.PathEscape(pkg)+"/"+url.PathEscape(repo)+"/"+url.PathEscape(arch))
+		res.WriteHeader(307)
+		return
 
-		prjStatus := GetCurrentStatus(prj)
-		if prjStatus == nil {
+		//		status := GetDetailedBuildStatus(prj, pkg, repo, arch)
+		data, err := obs.BuildLog(prj, pkg, repo, arch)
+		if err != nil {
+			res.WriteHeader(http.StatusInternalServerError)
+			common.LogError("Failed to fetch build log for:", prj, pkg, repo, arch, err)
 			return
 		}
+		defer data.Close()
 
-		for _, r := range prjStatus.Result {
-			if r.Arch == arch && r.Repository == repo {
-				for _, status := range r.Status {
-					if status.Package == pkg {
-						res.Write(PackageStatusSummarySvg(status))
-						return
-					}
-				}
-			}
-		}
+		io.Copy(res, data)
 	})
 
-	go ProcessUpdates()
-
 	if *disableTls {
 		log.Fatal(http.ListenAndServe(*listen, nil))
 	} else {

obs-status-service/main_test.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+	"compress/bzip2"
+	"encoding/json"
+	"io"
+	"os"
+	"testing"
+
+	"src.opensuse.org/autogits/common"
+)
+
+func TestStatusSvg(t *testing.T) {
+	ObsUrl = &[]string{"http://nothing.is.here"}[0]
+	os.WriteFile("teststatus.svg", BuildStatusSvg(nil, &common.PackageBuildStatus{
+		Package: "foo",
+		Code:    "succeeded",
+		Details: "more success here",
+	}), 0o777)
+
+	data := []*common.BuildResult{
+		{
+			Project:    "project:foo",
+			Repository: "repo1",
+			Arch:       "x86_64",
+			Status: []*common.PackageBuildStatus{
+				{
+					Package: "pkg1",
+					Code:    "succeeded",
+				},
+				{
+					Package: "pkg2",
+					Code:    "failed",
+				},
+			},
+		},
+		{
+			Project:    "project:foo",
+			Repository: "repo1",
+			Arch:       "s390x",
+			Status: []*common.PackageBuildStatus{
+				{
+					Package: "pkg1",
+					Code:    "succeeded",
+				},
+				{
+					Package: "pkg2",
+					Code:    "unresolveable",
+				},
+			},
+		},
+		{
+			Project:    "project:foo",
+			Repository: "repo1",
+			Arch:       "i586",
+			Status: []*common.PackageBuildStatus{
+				{
+					Package: "pkg1",
+					Code:    "succeeded",
+				},
+				{
+					Package: "pkg2",
+					Code:    "blocked",
+					Details: "foo bar is why",
+				},
+			},
+		},
+		{
+			Project:    "project:foo",
+			Repository: "TW",
+			Arch:       "s390",
+			Status: []*common.PackageBuildStatus{
+				{
+					Package: "pkg1",
+					Code:    "excluded",
+				},
+				{
+					Package: "pkg2",
+					Code:    "failed",
+				},
+			},
+		},
+	}
+
+	os.WriteFile("testpackage.svg", PackageStatusSummarySvg("pkg2", data), 0o777)
+	os.WriteFile("testproject.svg", ProjectStatusSummarySvg(data), 0o777)
+}
+
+func TestFactoryResults(t *testing.T) {
+	data, err := os.Open("factory.results.json.bz2")
+	if err != nil {
+		t.Fatal("Openning factory.results.json.bz2 failed:", err)
+	}
+	UncompressedData, err := io.ReadAll(bzip2.NewReader(data))
+	if err != nil {
+		t.Fatal("Reading factory.results.json.bz2 failed:", err)
+	}
+
+	var results []*common.BuildResult
+	if err := json.Unmarshal(UncompressedData, &results); err != nil {
+		t.Fatal("Failed parsing test data", err)
+	}
+
+	// add tests here
+	tests := []struct {
+		name string
+	}{
+		// add test data here
+		{
+			name: "First test",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			// and test code here
+		})
+	}
+}
+

obs-status-service/mimeheader.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"net/http"
+	"strings"
+)
+
+type MimeHeader struct {
+	MimeHeader string
+}
+
+const (
+	JsonMime = "application/json"
+	XmlMime  = "application/obs+xml"
+	SvgMime  = "image/svg+xml"
+)
+
+var AcceptedStatusMimes []string = []string{
+	SvgMime,
+	JsonMime,
+	XmlMime,
+}
+
+func ParseMimeHeader(req *http.Request) *MimeHeader {
+	proposedMimes := req.Header.Values("Accept")
+	mime := MimeHeader{MimeHeader: SvgMime}
+	if len(proposedMimes) == 0 {
+		return &mime
+	}
+
+	for _, m := range proposedMimes {
+		for _, am := range AcceptedStatusMimes {
+			if strings.Contains(m, am) {
+				mime.MimeHeader = am
+				return &mime
+			}
+		}
+	}
+	return &mime
+}
+
+func (m *MimeHeader) IsJson() bool {
+	return m.MimeHeader == JsonMime
+}
+
+func (m *MimeHeader) IsXml() bool {
+	return m.MimeHeader == XmlMime
+}
+
+func (m *MimeHeader) IsSvg() bool {
+	return m.MimeHeader == SvgMime
+}
+
+func (m *MimeHeader) MimeType() string {
+	if m.IsJson() {
+		return JsonMime
+	} else if m.IsXml() {
+		return XmlMime
+	}
+
+	return SvgMime // default
+}

obs-status-service/redis.go

@@ -0,0 +1,266 @@
+package main
+
+import (
+	"context"
+	"slices"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+	"src.opensuse.org/autogits/common"
+)
+
+var RepoStatus []*common.BuildResult = []*common.BuildResult{}
+var RepoStatusLock *sync.RWMutex = &sync.RWMutex{}
+
+var redisClient *redis.Client
+
+func RedisConnect(RedisUrl string) {
+	opts, err := redis.ParseURL(RedisUrl)
+	if err != nil {
+		panic(err)
+	}
+
+	redisClient = redis.NewClient(opts)
+}
+
+func UpdateResults(r *common.BuildResult) {
+	RepoStatusLock.Lock()
+	defer RepoStatusLock.Unlock()
+
+	updateResultsWithoutLocking(r)
+}
+
+func updateResultsWithoutLocking(r *common.BuildResult) {
+	key := "result." + r.Project + "/" + r.Repository + "/" + r.Arch
+	data, err := redisClient.HGetAll(context.Background(), key).Result()
+	if err != nil {
+		common.LogError("Failed fetching build results for", key, err)
+	}
+
+	reset_time := time.Date(1000, 1, 1, 1, 1, 1, 1, time.Local)
+	for _, pkg := range r.Status {
+		pkg.LastUpdate = reset_time
+	}
+	r.LastUpdate = time.Now()
+	for pkg, result := range data {
+		if strings.HasPrefix(result, "scheduled") {
+			// TODO: lookup where's building
+			result = "building"
+		}
+
+		var idx int
+		var found bool
+		var code string
+		var details string
+
+		if pos := strings.IndexByte(result, ':'); pos > -1 && pos < len(result) {
+			code = result[0:pos]
+			details = result[pos+1:]
+		} else {
+			code = result
+			details = ""
+		}
+
+		if idx, found = slices.BinarySearchFunc(r.Status, &common.PackageBuildStatus{Package: pkg}, common.PackageBuildStatusComp); found {
+			res := r.Status[idx]
+			res.LastUpdate = r.LastUpdate
+			res.Code = code
+			res.Details = details
+		} else {
+			r.Status = slices.Insert(r.Status, idx, &common.PackageBuildStatus{
+				Package:    pkg,
+				Code:       code,
+				Details:    details,
+				LastUpdate: r.LastUpdate,
+			})
+		}
+	}
+	for idx := 0; idx < len(r.Status); {
+		if r.Status[idx].LastUpdate == reset_time {
+			r.Status = slices.Delete(r.Status, idx, idx+1)
+		} else {
+			idx++
+		}
+	}
+}
+
+func FindProjectResults(project string) []*common.BuildResult {
+	RepoStatusLock.RLock()
+	defer RepoStatusLock.RUnlock()
+
+	return FindProjectResultsNoLock(project)
+}
+
+func FindProjectResultsNoLock(project string) []*common.BuildResult {
+	ret := make([]*common.BuildResult, 0, 8)
+	idx, _ := slices.BinarySearchFunc(RepoStatus, &common.BuildResult{Project: project}, common.BuildResultComp)
+	for idx < len(RepoStatus) && RepoStatus[idx].Project == project {
+		ret = append(ret, RepoStatus[idx])
+		idx++
+	}
+	return ret
+}
+
+func FindRepoResults(project, repo string) []*common.BuildResult {
+	RepoStatusLock.RLock()
+	defer RepoStatusLock.RUnlock()
+
+	return FindRepoResultsNoLock(project, repo)
+}
+
+func FindRepoResultsNoLock(project, repo string) []*common.BuildResult {
+	ret := make([]*common.BuildResult, 0, 8)
+	idx, _ := slices.BinarySearchFunc(RepoStatus, &common.BuildResult{Project: project, Repository: repo}, common.BuildResultComp)
+	for idx < len(RepoStatus) && RepoStatus[idx].Project == project && RepoStatus[idx].Repository == repo {
+		ret = append(ret, RepoStatus[idx])
+		idx++
+	}
+	return ret
+}
+
+func FindPackages(pkg string) []string {
+	RepoStatusLock.RLock()
+	defer RepoStatusLock.RUnlock()
+
+	return FindPackagesNoLock(pkg)
+}
+
+func FindPackagesNoLock(pkg string) []string {
+	data := make([]string, 0, 100)
+	for _, repo := range RepoStatus {
+		for _, status := range repo.Status {
+			if pkg == status.Package {
+				entry := repo.Project + "/" + pkg
+				if idx, found := slices.BinarySearch(data, entry); !found {
+					data = slices.Insert(data, idx, entry)
+					if len(data) >= 100 {
+						return data
+					}
+				}
+			}
+		}
+	}
+	return data
+}
+
+func FindAndUpdateProjectResults(project string) []*common.BuildResult {
+	res := FindProjectResults(project)
+	wg := &sync.WaitGroup{}
+	now := time.Now()
+	for _, r := range res {
+		if now.Sub(r.LastUpdate).Abs() < time.Second*10 {
+			// 1 update per 10 second for now
+			continue
+		}
+		wg.Add(1)
+		go func() {
+			UpdateResults(r)
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+	return res
+}
+
+func FindAndUpdateRepoResults(project, repo string) []*common.BuildResult {
+	res := FindRepoResults(project, repo)
+	wg := &sync.WaitGroup{}
+	now := time.Now()
+	for _, r := range res {
+		if now.Sub(r.LastUpdate).Abs() < time.Second*10 {
+			// 1 update per 10 second for now
+			continue
+		}
+		wg.Add(1)
+		go func() {
+			UpdateResults(r)
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+	return res
+}
+
+func RescanRepositories() error {
+	ctx := context.Background()
+	var cursor uint64
+	var err error
+
+	common.LogDebug("** starting rescanning ...")
+	RepoStatusLock.Lock()
+	for _, repo := range RepoStatus {
+		repo.Dirty = false
+	}
+	RepoStatusLock.Unlock()
+	var count int
+
+	projectsLooked := make([]string, 0, 10000)
+
+	for {
+		var data []string
+		data, cursor, err = redisClient.ScanType(ctx, cursor, "", 1000, "hash").Result()
+
+		if err != nil {
+			return err
+		}
+
+		wg := &sync.WaitGroup{}
+		RepoStatusLock.Lock()
+		for _, repo := range data {
+			r := strings.Split(repo, "/")
+			if len(r) != 3 || len(r[0]) < 8 || r[0][0:7] != "result." {
+				continue
+			}
+			d := &common.BuildResult{
+				Project:    r[0][7:],
+				Repository: r[1],
+				Arch:       r[2],
+			}
+
+			var pos int
+			var found bool
+			if pos, found = slices.BinarySearchFunc(RepoStatus, d, common.BuildResultComp); found {
+				RepoStatus[pos].Dirty = true
+			} else {
+				d.Dirty = true
+				RepoStatus = slices.Insert(RepoStatus, pos, d)
+				count++
+			}
+
+			// fetch all keys, one per non-maintenance/non-home: projects, for package search
+			if idx, found := slices.BinarySearch(projectsLooked, d.Project); !found && !strings.Contains(d.Project, ":Maintenance:") && (len(d.Project) < 5 || d.Project[0:5] != "home:") {
+				projectsLooked = slices.Insert(projectsLooked, idx, d.Project)
+				wg.Add(1)
+				go func(r *common.BuildResult) {
+					updateResultsWithoutLocking(r)
+					wg.Done()
+				}(RepoStatus[pos])
+			}
+		}
+		wg.Wait()
+		RepoStatusLock.Unlock()
+
+		if cursor == 0 {
+			break
+		}
+	}
+	common.LogDebug("  added a total", count, "repos")
+	count = 0
+
+	RepoStatusLock.Lock()
+	for i := 0; i < len(RepoStatus); {
+		if !RepoStatus[i].Dirty {
+			RepoStatus = slices.Delete(RepoStatus, i, i+1)
+			count++
+		} else {
+			i++
+		}
+	}
+	RepoStatusLock.Unlock()
+	common.LogDebug("  removed", count, "repos")
+	common.LogDebug("  total repos:", len(RepoStatus))
+
+	return nil
+}

obs-status-service/status.go

@@ -1,82 +0,0 @@
-package main
-
-import (
-	"log"
-	"slices"
-	"sync"
-	"time"
-
-	"src.opensuse.org/autogits/common"
-)
-
-var WatchedRepos []string
-var mutex sync.Mutex
-
-var StatusUpdateCh chan StatusUpdateMsg = make(chan StatusUpdateMsg)
-
-var statusMutex sync.RWMutex
-var CurrentStatus map[string]*common.BuildResultList = make(map[string]*common.BuildResultList)
-
-type StatusUpdateMsg struct {
-	ObsProject string
-	Result     *common.BuildResultList
-}
-
-func GetCurrentStatus(project string) *common.BuildResultList {
-	statusMutex.RLock()
-	defer statusMutex.RUnlock()
-
-	if ret, found := CurrentStatus[project]; found {
-		return ret
-	} else {
-		go WatchObsProject(obs, project)
-		return nil
-	}
-}
-
-func ProcessUpdates() {
-	for {
-		msg := <-StatusUpdateCh
-
-		statusMutex.Lock()
-		CurrentStatus[msg.ObsProject] = msg.Result
-
-	drainedChannel:
-		for {
-			select {
-			case msg = <-StatusUpdateCh:
-				CurrentStatus[msg.ObsProject] = msg.Result
-			default:
-				statusMutex.Unlock()
-				break drainedChannel
-			}
-		}
-	}
-}
-
-func WatchObsProject(obs common.ObsStatusFetcherWithState, ObsProject string) {
-	old_state := ""
-
-	mutex.Lock()
-	if pos, found := slices.BinarySearch(WatchedRepos, ObsProject); found {
-		mutex.Unlock()
-		return
-	} else {
-		WatchedRepos = slices.Insert(WatchedRepos, pos, ObsProject)
-		mutex.Unlock()
-	}
-
-	LogDebug("+ watching", ObsProject)
-	opts := common.BuildResultOptions{}
-	for {
-		state, err := obs.BuildStatusWithState(ObsProject, &opts)
-		if err != nil {
-			log.Println(" *** Error fetching build for", ObsProject, err)
-			time.Sleep(time.Minute)
-		} else {
-			opts.OldState = state.State
-			LogDebug("  --> update", ObsProject, " => ", old_state)
-			StatusUpdateCh <- StatusUpdateMsg{ObsProject: ObsProject, Result: state}
-		}
-	}
-}

obs-status-service/status_test.go

@@ -1,34 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"go.uber.org/mock/gomock"
-	"src.opensuse.org/autogits/common"
-	mock_common "src.opensuse.org/autogits/common/mock"
-)
-
-func TestWatchObsProject(t *testing.T) {
-	tests := []struct {
-		name string
-		res  common.BuildResultList
-	}{
-		{
-			name: "two requests",
-			res:  common.BuildResultList{
-				State: "success",
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			ctl := gomock.NewController(t)
-			obs := mock_common.NewMockObsStatusFetcherWithState(ctl)
-
-			obs.EXPECT().BuildStatusWithState("test:foo", "").Return(&test.res, nil)
-
-			WatchObsProject(obs, "test:foo")
-		})
-	}
-}

obs-status-service/svg.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"html"
+	"net/url"
+	"slices"
+	"strings"
+)
+
+type SvgWriter struct {
+	ypos   float64
+	header []byte
+	out    bytes.Buffer
+}
+
+const (
+	SvgType_Package = iota
+	SvgType_Project
+)
+
+func NewSvg(SvgType int) *SvgWriter {
+	svg := &SvgWriter{}
+	svg.header = []byte(`<svg version="2.0" overflow="auto" width="40ex" height="`)
+	svg.out.WriteString(`em" xmlns="http://www.w3.org/2000/svg">`)
+	switch SvgType {
+	case SvgType_Package:
+		svg.out.WriteString(`<defs>
+	    <g id="s">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="green" fill="#efe" rx="5" />
+	      <text x="2.5ex" y="1.1em">succeeded</text>
+	    </g>
+	    <g id="f">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="red" fill="#fee" rx="5" />
+	      <text x="5ex" y="1.1em">failed</text>
+	    </g>
+	    <g id="b">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="grey" fill="#fbf" rx="5" />
+	      <text x="3.75ex" y="1.1em">blocked</text>
+	    </g>
+	    <g id="broken">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="grey" fill="#fff" rx="5" />
+	      <text x="4.5ex" y="1.1em" stroke="red" fill="red">broken</text>
+	    </g>
+	    <g id="build">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="yellow" fill="#664" rx="5" />
+	      <text x="3.75ex" y="1.1em" fill="yellow">building</text>
+	    </g>
+	    <g id="u">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="yellow" fill="#555" rx="5" />
+	    <text x="2ex" y="1.1em" fill="orange">unresolvable</text>
+	    </g>
+	    <g id="scheduled">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="blue" fill="none" rx="5" />
+	      <text x="3ex" y="1.1em" stroke="none" fill="blue">scheduled</text>
+	    </g>
+	    <g id="d">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="grey" fill="none" rx="5" />
+	      <text x="4ex" y="1.1em" stroke="none" fill="grey">disabled</text>
+	    </g>
+	    <g id="e">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="grey" fill="none" rx="5" />
+	      <text x="4ex" y="1.1em" stroke="none" fill="#aaf">excluded</text>
+	    </g>
+	    <g id="un">
+	      <rect width="15ex" height="1.5em" stroke-width="1" stroke="grey" fill="none" rx="5" />
+	      <text x="4ex" y="1.1em" stroke="none" fill="grey">unknown</text>
+	    </g>
+		<rect id="repotitle" width="100%" height="2em" stroke-width="1" stroke="grey" fill="grey" rx="2" />
+	  </defs>`)
+
+	case SvgType_Project:
+		svg.out.WriteString(`<defs>
+		</defs>`)
+	}
+
+	return svg
+}
+
+func (svg *SvgWriter) WriteTitle(title string) {
+	svg.out.WriteString(`<text stroke="black" fill="black" x="1ex" y="` + fmt.Sprint(svg.ypos-.5) + `em">` + html.EscapeString(title) + "</text>")
+	svg.ypos += 2.5
+
+}
+
+func (svg *SvgWriter) WriteSubtitle(subtitle string) {
+	svg.out.WriteString(`<use href="#repotitle" y="` + fmt.Sprint(svg.ypos-2) + `em"/>`)
+	svg.out.WriteString(`<text stroke="black" fill="black" x="3ex" y="` + fmt.Sprint(svg.ypos-.6) + `em">` + html.EscapeString(subtitle) + `</text>`)
+	svg.ypos += 2
+}
+
+func (svg *SvgWriter) WritePackageStatus(loglink, arch, status, detail string) {
+	StatusToSVG := func(S string) string {
+		switch S {
+		case "succeeded":
+			return "s"
+		case "failed":
+			return "f"
+		case "broken", "scheduled":
+			return S
+		case "blocked":
+			return "b"
+		case "building":
+			return "build"
+		case "unresolvable":
+			return "u"
+		case "disabled":
+			return "d"
+		case "excluded":
+			return "e"
+		}
+		return "un"
+	}
+
+	svg.out.WriteString(`<text fill="#113" x="5ex" y="` + fmt.Sprint(svg.ypos-.6) + `em">` + html.EscapeString(arch) + `</text>`)
+	svg.out.WriteString(`<g>`)
+	if len(loglink) > 0 {
+		u, err := url.Parse(loglink)
+		if err == nil {
+			svg.out.WriteString(`<a href="` + u.String() + `" target="_blank" rel="noopener">`)
+		}
+	}
+	svg.out.WriteString(`<use href="#` + StatusToSVG(status) + `" x="20ex" y="` + fmt.Sprint(svg.ypos-1.7) + `em"/>`)
+	if len(loglink) > 0 {
+		svg.out.WriteString(`</a>`)
+	}
+	if len(detail) > 0 {
+		svg.out.WriteString(`<title>` + html.EscapeString(detail) + "</title>")
+	}
+
+	svg.out.WriteString("</g>\n")
+	svg.ypos += 2
+}
+
+func (svg *SvgWriter) WriteProjectStatus(project, repo, arch, status string, count int) {
+	u, err := url.Parse(*ObsUrl + "/project/monitor/" + url.PathEscape(project) + "?defaults=0&amp;" + url.QueryEscape(status) + "=1&amp;arch_" + url.QueryEscape(arch) + "=1&amp;repo_" + url.QueryEscape(strings.ReplaceAll(repo, ".", "_")) + "=1")
+	if err != nil {
+		return
+	}
+
+	svg.out.WriteString(`<g><a href="` + u.String() + `" target="_blank" rel="noopener">` + "\n" +
+		`<text fill="#113" x="5ex" y="` + fmt.Sprint(svg.ypos-0.6) + "em\">\n" +
+		html.EscapeString(status+": ") + fmt.Sprint(count) + "</text></a></g>\n")
+	svg.ypos += 2
+}
+
+func (svg *SvgWriter) GenerateSvg() []byte {
+	return slices.Concat(svg.header, []byte(fmt.Sprint(svg.ypos)), svg.out.Bytes(), []byte("</svg>"))
+}

reparent-bot/README.md

@@ -0,0 +1,24 @@
+Reparent Bot
+============
+
+To be able to put new parents of repositories as special forks into
+pool and other projects.
+
+
+Areas of Responsibilities
+-------------------------
+
+* monitor issues for Add packages
+  + issue creator *must be* owner of the repo, OR
+  + repository must not be a fork
+* assign organization Owner to review request
+* reparent the repository and create a PR
+* remove non-accepted repositories from /pool, if no other
+  branches are relevant here
+
+Target Usage
+------------
+
+* devel and released products
+
+

systemd/gitea-events-rabbitmq-publisher.service

@@ -5,7 +5,7 @@ After=network-online.target
 [Service]
 Type=exec
 ExecStart=/usr/bin/gitea-events-rabbitmq-publisher
-EnvironmentFile=-/etc/sysconfig/gitea-events-rabbitmq-publisher.env
+EnvironmentFile=-/etc/default/gitea-events-rabbitmq-publisher.env
 DynamicUser=yes
 NoNewPrivileges=yes
 ProtectSystem=strict

systemd/group-review@.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=Group Review bot for %i
+After=network-online.target
+
+[Service]
+Type=exec
+ExecStart=/usr/bin/group-review %i
+EnvironmentFile=-/etc/default/group-review/%i.env
+DynamicUser=yes
+NoNewPrivileges=yes
+ProtectSystem=strict
+
+[Install]
+WantedBy=multi-user.target
+

systemd/obs-staging-bot.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=Staging bot for project git PRs in OBS
+After=network-online.target
+
+[Service]
+Type=exec
+ExecStart=/usr/bin/obs-staging-bot
+EnvironmentFile=-/etc/default/obs-staging-bot.env
+DynamicUser=yes
+NoNewPrivileges=yes
+ProtectSystem=strict
+
+[Install]
+WantedBy=multi-user.target
+
+

systemd/obs-status-service.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=OBS build status as SVG service
+After=network-online.target
+
+[Service]
+Type=exec
+Restart=on-failure
+ExecStart=/usr/bin/obs-status-service
+EnvironmentFile=-/etc/default/obs-status-service.env
+DynamicUser=yes
+ProtectSystem=strict
+
+[Install]
+WantedBy=multi-user.target
+

systemd/workflow-direct@.service

@@ -0,0 +1,19 @@
+[Unit]
+Description=WorkflowDirect git bot for %i
+After=network-online.target
+
+[Service]
+Type=exec
+ExecStart=/usr/bin/workflow-direct
+EnvironmentFile=-/etc/default/%i/workflow-direct.env
+DynamicUser=yes
+NoNewPrivileges=yes
+ProtectSystem=strict
+RuntimeDirectory=%i
+# SLES 15 doesn't have HOME set for dynamic users, so we improvise
+BindReadOnlyPaths=/etc/default/%i/known_hosts:/etc/ssh/ssh_known_hosts /etc/default/%i/config.json:%t/%i/config.json /etc/default/%i/id_ed25519 /etc/default/%i/id_ed25519.pub
+WorkingDirectory=%t/%i
+
+[Install]
+WantedBy=multi-user.target
+

test/main.go

@@ -0,0 +1,4 @@
+package main
+
+// exists only to import this for go.modules
+import "go.uber.org/mock/mockgen/model"

utils/hujson/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"io"
+	"log"
+	"os"
+
+	"github.com/tailscale/hujson"
+)
+
+func main() {
+	data, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		log.Println(err)
+		os.Exit(1)
+	}
+	json, err := hujson.Standardize(data)
+	if err != nil {
+		log.Println(err)
+		os.Exit(2)
+	}
+	_, err = os.Stdout.Write(json)
+	if err != nil {
+		log.Print(err)
+		os.Exit(3)
+	}
+}

utils/maintainer-update/main.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"slices"
+
+	"src.opensuse.org/autogits/common"
+)
+
+var (
+	pkg  = flag.String("package", "", "Package to modify")
+	rm   = flag.Bool("rm", false, "Remove maintainer from package")
+	add  = flag.Bool("add", false, "Add maintainer to package")
+	lint = flag.Bool("lint-only", false, "Reformat entire _maintainership.json only")
+)
+
+const maintainershipFile = "_maintainership.json"
+
+func WriteNewMaintainershipFile(m *common.MaintainershipMap, filename string) {
+	f, err := os.Create(filename + ".new")
+	common.PanicOnError(err)
+	common.PanicOnError(m.WriteMaintainershipFile(f))
+	common.PanicOnError(f.Close())
+	common.PanicOnError(os.Rename(filename+".new", filename))
+}
+
+func run() error {
+	flag.Parse()
+
+	filename := maintainershipFile
+	if *lint {
+		if len(flag.Args()) > 0 {
+			filename = flag.Arg(0)
+		}
+	}
+
+	data, err := os.ReadFile(filename)
+	if os.IsNotExist(err) {
+		return err
+	}
+	if err != nil {
+		return err
+	}
+
+	m, err := common.ParseMaintainershipData(data)
+	if err != nil {
+		return fmt.Errorf("Failed to parse JSON: %w", err)
+	}
+
+	if *lint {
+		m.Raw = nil // forces a rewrite
+	} else {
+		users := flag.Args()
+		if len(users) > 0 {
+			maintainers, ok := m.Data[*pkg]
+			if !ok && !*add {
+				return fmt.Errorf("No package %s and not adding one.", *pkg)
+			}
+
+			if *add {
+				for _, u := range users {
+					if !slices.Contains(maintainers, u) {
+						maintainers = append(maintainers, u)
+					}
+				}
+			}
+
+			if *rm {
+				newMaintainers := make([]string, 0, len(maintainers))
+				for _, m := range maintainers {
+					if !slices.Contains(users, m) {
+						newMaintainers = append(newMaintainers, m)
+					}
+				}
+				maintainers = newMaintainers
+			}
+
+			if len(maintainers) > 0 {
+				slices.Sort(maintainers)
+				m.Data[*pkg] = maintainers
+			} else {
+				delete(m.Data, *pkg)
+			}
+		}
+	}
+
+	WriteNewMaintainershipFile(m, filename)
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		common.LogError(err)
+		os.Exit(1)
+	}
+}

utils/maintainer-update/main_test.go

@@ -0,0 +1,243 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"os"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("BE_MAIN") == "1" {
+		main()
+		return
+	}
+	os.Exit(m.Run())
+}
+
+func TestRun(t *testing.T) {
+	tests := []struct {
+		name          string
+		inData        string
+		expectedOut   string
+		params        []string
+		expectedError string
+		isDir         bool
+	}{
+		{
+			name:        "add user to existing package",
+			inData:      `{"pkg1": ["user1"]}`,
+			params:      []string{"-package", "pkg1", "-add", "user2"},
+			expectedOut: `{"pkg1": ["user1", "user2"]}`,
+		},
+		{
+			name:        "add user to new package",
+			inData:      `{"pkg1": ["user1"]}`,
+			params:      []string{"-package", "pkg2", "-add", "user2"},
+			expectedOut: `{"pkg1": ["user1"], "pkg2": ["user2"]}`,
+		},
+		{
+			name:        "no-op with no users",
+			inData:      `{"pkg1": ["user1"]}`,
+			params:      []string{"-package", "pkg1", "-add"},
+			expectedOut: `{"pkg1": ["user1"]}`,
+		},
+		{
+			name:        "add existing user",
+			inData:      `{"pkg1": ["user1", "user2"]}`,
+			params:      []string{"-package", "pkg1", "-add", "user2"},
+			expectedOut: `{"pkg1": ["user1", "user2"]}`,
+		},
+		{
+			name:        "remove user from package",
+			inData:      `{"pkg1": ["user1", "user2"]}`,
+			params:      []string{"-package", "pkg1", "-rm", "user2"},
+			expectedOut: `{"pkg1": ["user1"]}`,
+		},
+		{
+			name:        "remove last user from package",
+			inData:      `{"pkg1": ["user1"]}`,
+			params:      []string{"-package", "pkg1", "-rm", "user1"},
+			expectedOut: `{}`,
+		},
+		{
+			name:        "remove non-existent user",
+			inData:      `{"pkg1": ["user1"]}`,
+			params:      []string{"-package", "pkg1", "-rm", "user2"},
+			expectedOut: `{"pkg1": ["user1"]}`,
+		},
+		{
+			name:        "lint only unsorted",
+			inData:      `{"pkg1": ["user2", "user1"]}`,
+			params:      []string{"-lint-only"},
+			expectedOut: `{"pkg1": ["user1", "user2"]}`,
+		},
+		{
+			name:        "lint only no changes",
+			inData:      `{"pkg1": ["user1", "user2"]}`,
+			params:      []string{"-lint-only"},
+			expectedOut: `{"pkg1": ["user1", "user2"]}`,
+		},
+		{
+			name:          "no file",
+			params:        []string{},
+			expectedError: "no such file or directory",
+		},
+		{
+			name:          "invalid json",
+			inData:        `{"pkg1": ["user1"`,
+			params:        []string{},
+			expectedError: "Failed to parse JSON",
+		},
+		{
+			name:        "add and remove",
+			inData:      `{"pkg1": ["user1", "user2"]}`,
+			params:      []string{"-package", "pkg1", "-add", "user3"},
+			expectedOut: `{"pkg1": ["user1", "user2", "user3"]}`,
+		},
+		{
+			name:        "lint specific file",
+			inData:      `{"pkg1": ["user2", "user1"]}`,
+			params:      []string{"-lint-only", "other.json"},
+			expectedOut: `{"pkg1": ["user1", "user2"]}`,
+		},
+		{
+			name:        "add user to package when it was not there before",
+			inData:      `{}`,
+			params:      []string{"-package", "newpkg", "-add", "user1"},
+			expectedOut: `{"newpkg": ["user1"]}`,
+		},
+		{
+			name:          "unreadable file (is a directory)",
+			isDir:         true,
+			expectedError: "is a directory",
+		},
+		{
+			name:          "remove user from non-existent package",
+			inData:        `{"pkg1": ["user1"]}`,
+			params:        []string{"-package", "pkg2", "-rm", "user2"},
+			expectedError: "No package pkg2 and not adding one.",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := t.TempDir()
+			oldWd, _ := os.Getwd()
+			_ = os.Chdir(dir)
+			defer os.Chdir(oldWd)
+
+			targetFile := maintainershipFile
+			if tt.name == "lint specific file" {
+				targetFile = "other.json"
+			}
+
+			if tt.isDir {
+				_ = os.Mkdir(targetFile, 0755)
+			} else if tt.inData != "" {
+				_ = os.WriteFile(targetFile, []byte(tt.inData), 0644)
+			}
+
+			flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
+			pkg = flag.String("package", "", "Package to modify")
+			rm = flag.Bool("rm", false, "Remove maintainer from package")
+			add = flag.Bool("add", false, "Add maintainer to package")
+			lint = flag.Bool("lint-only", false, "Reformat entire _maintainership.json only")
+
+			os.Args = append([]string{"cmd"}, tt.params...)
+			err := run()
+
+			if tt.expectedError != "" {
+				if err == nil {
+					t.Fatalf("expected error containing %q, but got none", tt.expectedError)
+				}
+				if !strings.Contains(err.Error(), tt.expectedError) {
+					t.Fatalf("expected error containing %q, got %q", tt.expectedError, err.Error())
+				}
+			} else if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if tt.expectedOut != "" {
+				data, _ := os.ReadFile(targetFile)
+				var got, expected map[string][]string
+				_ = json.Unmarshal(data, &got)
+				_ = json.Unmarshal([]byte(tt.expectedOut), &expected)
+
+				if len(got) == 0 && len(expected) == 0 {
+					return
+				}
+
+				if !reflect.DeepEqual(got, expected) {
+					t.Fatalf("expected %v, got %v", expected, got)
+				}
+			}
+		})
+	}
+}
+
+func TestMainRecursive(t *testing.T) {
+	tests := []struct {
+		name        string
+		inData      string
+		expectedOut string
+		params      []string
+		expectExit  bool
+	}{
+		{
+			name:        "test main() via recursive call",
+			inData:      `{"pkg1": ["user1"]}`,
+			params:      []string{"-package", "pkg1", "-add", "user2"},
+			expectedOut: `{"pkg1": ["user1", "user2"]}`,
+		},
+		{
+			name:       "test main() failure",
+			params:     []string{"-package", "pkg1"},
+			expectExit: true,
+		},
+	}
+
+	exe, _ := os.Executable()
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := t.TempDir()
+			oldWd, _ := os.Getwd()
+			_ = os.Chdir(dir)
+			defer os.Chdir(oldWd)
+
+			if tt.inData != "" {
+				_ = os.WriteFile(maintainershipFile, []byte(tt.inData), 0644)
+			}
+
+			cmd := exec.Command(exe, append([]string{"-test.run=None"}, tt.params...)...)
+			cmd.Env = append(os.Environ(), "BE_MAIN=1")
+			out, runErr := cmd.CombinedOutput()
+
+			if tt.expectExit {
+				if runErr == nil {
+					t.Fatalf("expected exit with error, but it succeeded")
+				}
+				return
+			}
+
+			if runErr != nil {
+				t.Fatalf("unexpected error: %v: %s", runErr, string(out))
+			}
+
+			if tt.expectedOut != "" {
+				data, _ := os.ReadFile(maintainershipFile)
+				var got, expected map[string][]string
+				_ = json.Unmarshal(data, &got)
+				_ = json.Unmarshal([]byte(tt.expectedOut), &expected)
+
+				if !reflect.DeepEqual(got, expected) {
+					t.Fatalf("expected %v, got %v", expected, got)
+				}
+			}
+		})
+	}
+}

vendor/github.com/asaskevich/govalidator/.gitignore

@@ -0,0 +1,15 @@
+bin/
+.idea/
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+

vendor/github.com/asaskevich/govalidator/.travis.yml

@@ -0,0 +1,12 @@
+language: go
+dist: xenial
+go:
+  - '1.10'
+  - '1.11'
+  - '1.12'
+  - '1.13'
+  - 'tip'
+
+script:
+     - go test -coverpkg=./... -coverprofile=coverage.info -timeout=5s
+     - bash <(curl -s https://codecov.io/bash)

vendor/github.com/asaskevich/govalidator/CODE_OF_CONDUCT.md

@@ -0,0 +1,43 @@
+# Contributor Code of Conduct
+
+This project adheres to [The Code Manifesto](http://codemanifesto.com)
+as its guidelines for contributor interactions.
+
+## The Code Manifesto
+
+We want to work in an ecosystem that empowers developers to reach their
+potential — one that encourages growth and effective collaboration. A space
+that is safe for all.
+
+A space such as this benefits everyone that participates in it. It encourages
+new developers to enter our field. It is through discussion and collaboration
+that we grow, and through growth that we improve.
+
+In the effort to create such a place, we hold to these values:
+
+1. **Discrimination limits us.** This includes discrimination on the basis of
+   race, gender, sexual orientation, gender identity, age, nationality,
+   technology and any other arbitrary exclusion of a group of people.
+2. **Boundaries honor us.** Your comfort levels are not everyone’s comfort
+   levels. Remember that, and if brought to your attention, heed it.
+3. **We are our biggest assets.** None of us were born masters of our trade.
+   Each of us has been helped along the way. Return that favor, when and where
+   you can.
+4. **We are resources for the future.** As an extension of #3, share what you
+   know. Make yourself a resource to help those that come after you.
+5. **Respect defines us.** Treat others as you wish to be treated. Make your
+   discussions, criticisms and debates from a position of respectfulness. Ask
+   yourself, is it true? Is it necessary? Is it constructive? Anything less is
+   unacceptable.
+6. **Reactions require grace.** Angry responses are valid, but abusive language
+   and vindictive actions are toxic. When something happens that offends you,
+   handle it assertively, but be respectful. Escalate reasonably, and try to
+   allow the offender an opportunity to explain themselves, and possibly
+   correct the issue.
+7. **Opinions are just that: opinions.** Each and every one of us, due to our
+   background and upbringing, have varying opinions. That is perfectly
+   acceptable. Remember this: if you respect your own opinions, you should
+   respect the opinions of others.
+8. **To err is human.** You might not intend it, but mistakes do happen and
+   contribute to build experience. Tolerate honest mistakes, and don't
+   hesitate to apologize if you make one yourself.