devel: ignore dot files

magic hash is when no files exist and echo "" is passed to md5sum
devel: handle build.specials.obscpio
2025-11-20 19:57:35 +01:00 · 2025-11-20 19:40:49 +01:00 · 2025-11-20 16:25:06 +01:00 · 2025-11-20 13:22:40 +01:00 · 2025-11-19 19:32:55 +01:00 · 2025-11-19 17:10:08 +01:00
31 changed files with 1214 additions and 906 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,2 @@
 *.osc
 *.conf
-utils/gitmodules-automerge/gitmodules-automerge
-utils/hujson/hujson
--- a/autogits.spec
+++ b/autogits.spec
@@ -17,7 +17,7 @@


 Name:           autogits
-Version:        0
+Version:        1
 Release:        0
 Summary:        GitWorkflow utilities
 License:        GPL-2.0-or-later
@@ -41,6 +41,7 @@ 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
@@ -56,10 +57,11 @@ with a topic


 %package gitea-status-proxy
-Summary:        gitea-status-proxy
+Summary:        Proxy for setting commit status in Gitea

 %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 group-review
 Summary:        Reviews of groups defined in ProjectGit
@@ -96,7 +98,6 @@ Provides:       /usr/bin/hujson

 %description utils
 HuJSON to JSON parser, using stdin -> stdout pipe
-gitmodules-automerge fixes conflicts in .gitmodules conflicts during merge


 %package workflow-direct
@@ -128,9 +129,6 @@ go build \
 go build \
   -C utils/hujson \
   -buildmode=pie
-go build \
-   -C utils/gitmodules-automerge \
-   -buildmode=pie
 go build \
   -C gitea-events-rabbitmq-publisher \
   -buildmode=pie
@@ -177,9 +175,9 @@ install -D -m0644 systemd/obs-staging-bot.service
 install -D -m0755 obs-status-service/obs-status-service                            %{buildroot}%{_bindir}/obs-status-service
 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/gitmodules-automerge/gitmodules-automerge                  %{buildroot}%{_bindir}/gitmodules-automerge

 %pre gitea-events-rabbitmq-publisher
 %service_add_pre gitea-events-rabbitmq-publisher.service
@@ -217,6 +215,18 @@ install -D -m0755 utils/gitmodules-automerge/gitmodules-automerge
 %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
@@ -261,12 +271,12 @@ install -D -m0755 utils/gitmodules-automerge/gitmodules-automerge
 %files utils
 %license COPYING
 %{_bindir}/hujson
-%{_bindir}/gitmodules-automerge

 %files workflow-direct
 %license COPYING
 %doc workflow-direct/README.md
 %{_bindir}/workflow-direct
+%{_unitdir}/workflow-direct@.service

 %files workflow-pr
 %license COPYING
--- a/common/config.go
+++ b/common/config.go
@@ -61,6 +61,20 @@ type Permissions struct {
 	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
@@ -72,6 +86,8 @@ type AutogitConfig struct {
 	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
@@ -188,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
 		}
@@ -273,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
--- a/common/config_test.go
+++ b/common/config_test.go
@@ -10,6 +10,67 @@ 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{
 		{
@@ -21,6 +82,15 @@ func TestProjectConfigMatcher(t *testing.T) {
 			Branch:         "main",
 			GitProjectName: "test/prjgit#main",
 		},
+		{
+			Organization:   "test",
+			Branch:         "main",
+			GitProjectName: "test/bar#never_match",
+		},
+		{
+			Organization:   "test",
+			GitProjectName: "test/bar#main",
+		},
 	}

 	tests := []struct {
@@ -50,6 +120,20 @@ func TestProjectConfigMatcher(t *testing.T) {
 			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 {
@@ -105,6 +189,10 @@ func TestConfigWorkflowParser(t *testing.T) {
 			if config.ManualMergeOnly != false {
 				t.Fatal("This should be false")
 			}
+
+			if config.Label("foobar") != "foobar" {
+				t.Fatal("undefined label should return default value")
+			}
 		})
 	}
 }
--- a/common/git_parser.go
+++ b/common/git_parser.go
@@ -1,296 +0,0 @@
-package common
-
-import (
-	"errors"
-	"fmt"
-	"io"
-)
-
-const (
-	GitStatus_Untracked = 0
-	GitStatus_Modified  = 1
-	GitStatus_Ignored   = 2
-	GitStatus_Unmerged  = 3 // States[0..3] -- Stage1, Stage2, Stage3 of merge objects
-	GitStatus_Renamed   = 4 // orig name in States[0]
-)
-
-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 parseGit_HexString(data io.ByteReader) (string, error) {
-	str := make([]byte, 0, 32)
-	for {
-		c, err := data.ReadByte()
-		if err != nil {
-			return "", err
-		}
-		switch {
-		case c == 0 || c == ' ':
-			return string(str), nil
-		case c >= 'a' && c <= 'f':
-		case c >= 'A' && c <= 'F':
-		case c >= '0' && c <= '9':
-		default:
-			return "", errors.New("Invalid character in hex string:" + string(c))
-		}
-		str = append(str, c)
-	}
-}
-func parseGit_String(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 parseGit_StringWithSpace(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 {
-			return string(str), nil
-		}
-		str = append(str, c)
-	}
-}
-
-func skipGitStatusEntry(data io.ByteReader, skipSpaceLen int) error {
-	for skipSpaceLen > 0 {
-		c, err := data.ReadByte()
-		if err != nil {
-			return err
-		}
-		if c == ' ' {
-			skipSpaceLen--
-		}
-	}
-
-	return nil
-}
-
-func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
-	ret := GitStatusData{}
-	statusType, err := data.ReadByte()
-	if err != nil {
-		return nil, nil
-	}
-	switch statusType {
-	case '1':
-		var err error
-		if err = skipGitStatusEntry(data, 8); err != nil {
-			return nil, err
-		}
-		ret.Status = GitStatus_Modified
-		ret.Path, err = parseGit_StringWithSpace(data)
-		if err != nil {
-			return nil, err
-		}
-	case '2':
-		var err error
-		if err = skipGitStatusEntry(data, 9); err != nil {
-			return nil, err
-		}
-		ret.Status = GitStatus_Renamed
-		ret.Path, err = parseGit_StringWithSpace(data)
-		if err != nil {
-			return nil, err
-		}
-		ret.States[0], err = parseGit_StringWithSpace(data)
-		if err != nil {
-			return nil, err
-		}
-	case '?':
-		var err error
-		if err = skipGitStatusEntry(data, 1); err != nil {
-			return nil, err
-		}
-		ret.Status = GitStatus_Untracked
-		ret.Path, err = parseGit_StringWithSpace(data)
-		if err != nil {
-			return nil, err
-		}
-	case '!':
-		var err error
-		if err = skipGitStatusEntry(data, 1); err != nil {
-			return nil, err
-		}
-		ret.Status = GitStatus_Ignored
-		ret.Path, err = parseGit_StringWithSpace(data)
-		if err != nil {
-			return nil, err
-		}
-	case 'u':
-		var err error
-		if err = skipGitStatusEntry(data, 2); err != nil {
-			return nil, err
-		}
-		if ret.SubmoduleChanges, err = parseGit_String(data); err != nil {
-			return nil, err
-		}
-		if err = skipGitStatusEntry(data, 4); err != nil {
-			return nil, err
-		}
-
-		if ret.States[0], err = parseGit_HexString(data); err != nil {
-			return nil, err
-		}
-		if ret.States[1], err = parseGit_HexString(data); err != nil {
-			return nil, err
-		}
-		if ret.States[2], err = parseGit_HexString(data); err != nil {
-			return nil, err
-		}
-		ret.Status = GitStatus_Unmerged
-		ret.Path, err = parseGit_StringWithSpace(data)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, errors.New("Invalid status type" + string(statusType))
-	}
-	return &ret, nil
-}
-
-func parseGitStatusData(data io.ByteReader) (Data, error) {
-	ret := make([]GitStatusData, 0, 10)
-	for {
-		data, err := parseSingleStatusEntry(data)
-		if err != nil {
-			return nil, err
-		} else if data == nil {
-			break
-		}
-
-		ret = append(ret, *data)
-	}
-	return ret, nil
-}
-
-type Data interface{}
-
-type CommitStatus int
-
-const (
-	Add CommitStatus = iota
-	Rm
-	Copy
-	Modify
-	Rename
-	TypeChange
-	Unmerged
-	Unknown
-)
-
-type GitDiffRawData struct {
-	SrcMode, DstMode     string
-	SrcCommit, DstCommit string
-	Status               CommitStatus
-	Src, Dst             string
-}
-
-func parseGit_DiffIndexStatus(data io.ByteReader, d *GitDiffRawData) error {
-	b, err := data.ReadByte()
-	if err != nil {
-		return err
-	}
-
-	switch b {
-	case 'A':
-		d.Status = Add
-	case 'C':
-		d.Status = Copy
-	case 'D':
-		d.Status = Rm
-	case 'M':
-		d.Status = Modify
-	case 'R':
-		d.Status = Rename
-	case 'T':
-		d.Status = TypeChange
-	case 'U':
-		d.Status = Unmerged
-	case 'X':
-		return fmt.Errorf("Unexpected unknown change type. This is a git bug")
-	}
-	_, err = parseGit_StringWithSpace(data)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func parseSingleGitDiffIndexRawData(data io.ByteReader) (*GitDiffRawData, error) {
-	var ret GitDiffRawData
-
-	b, err := data.ReadByte()
-	if err != nil {
-		return nil, err
-	}
-	if b != ':' {
-		return nil, fmt.Errorf("Expected ':' but got '%s'", string(b))
-	}
-
-	if ret.SrcMode, err = parseGit_String(data); err != nil {
-		return nil, err
-	}
-	if ret.DstMode, err = parseGit_String(data); err != nil {
-		return nil, err
-	}
-	if ret.Src, err = parseGit_String(data); err != nil {
-		return nil, err
-	}
-	if ret.Dst, err = parseGit_String(data); err != nil {
-		return nil, err
-	}
-	if err = parseGit_DiffIndexStatus(data, &ret); err != nil {
-		return nil, err
-	}
-	ret.Dst = ret.Src
-	switch ret.Status {
-	case Copy, Rename:
-		if ret.Src, err = parseGit_StringWithSpace(data); err != nil {
-			return nil, err
-		}
-	}
-
-	return &ret, nil
-}
-
-func parseGitDiffIndexRawData(data io.ByteReader) (Data, error) {
-	ret := make([]GitDiffRawData, 0, 10)
-	for {
-		data, err := parseSingleGitDiffIndexRawData(data)
-		if err != nil {
-			return nil, err
-		} else if data == nil {
-			break
-		}
-
-		ret = append(ret, *data)
-	}
-	return ret, nil
-}
--- a/common/git_utils.go
+++ b/common/git_utils.go
@@ -19,7 +19,9 @@ package common
 */

 import (
+	"bufio"
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -42,11 +44,6 @@ type GitDirectoryLister interface {
 	GitDirectoryList(gitPath, commitId string) (dirlist map[string]string, err error)
 }

-type GitSubmoduleFileConflictResolver interface {
-	GitResolveConflicts(cwd, MergeBase, Head, MergeHead string) error
-	GitResolveSubmoduleFileConflict(s GitStatusData, cwd, mergeBase, head, mergeHead string) error
-}
-
 type GitStatusLister interface {
 	GitStatus(cwd string) ([]GitStatusData, error)
 }
@@ -78,7 +75,6 @@ type Git interface {
 	GitExecQuietOrPanic(cwd string, params ...string)

 	GitDiffLister
-	GitSubmoduleFileConflictResolver
 }

 type GitHandlerImpl struct {
@@ -354,23 +350,20 @@ 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",
+		"GIT_AUTHOR_NAME=" + e.GitCommiter,
+		"GIT_COMMITTER_NAME=" + e.GitCommiter,
+		"EMAIL=not@exist@src.opensuse.org",
 		"GIT_LFS_SKIP_SMUDGE=1",
 		"GIT_LFS_SKIP_PUSH=1",
-		"GIT_SSH_COMMAND=/usr/bin/ssh -o StrictHostKeyChecking=yes",
+		"GIT_SSH_COMMAND=/usr/bin/ssh -o StrictHostKeyChecking=yes" + identityFile,
 	}
-	if len(e.GitEmail) > 0 {
-		cmd.Env = append(cmd.Env, "EMAIL="+e.GitEmail)
-	}
-	if len(e.GitCommiter) > 0 {
-		cmd.Env = append(cmd.Env,
-			"GIT_AUTHOR_NAME="+e.GitCommiter,
-			"GIT_COMMITTER_NAME="+e.GitCommiter,
-		)
-	}
-
 	if len(ExtraGitParams) > 0 {
 		cmd.Env = append(cmd.Env, ExtraGitParams...)
 	}
@@ -1013,10 +1006,193 @@ func (e *GitHandlerImpl) GitSubmoduleCommitId(cwd, packageName, commitId string)
 	return subCommitId, len(subCommitId) > 0
 }

-func (e *GitHandlerImpl) GitExecWithDataParse(cwd string, dataprocessor func(io.ByteReader) (Data, error), gitcmd string, args ...string) (Data, error) {
-	LogDebug("getting", gitcmd)
-	args = append([]string{gitcmd}, args...)
-	cmd := exec.Command("/usr/bin/git", args...)
+const (
+	GitStatus_Untracked = 0
+	GitStatus_Modified  = 1
+	GitStatus_Ignored   = 2
+	GitStatus_Unmerged  = 3 // States[0..3] -- Stage1, Stage2, Stage3 of merge objects
+	GitStatus_Renamed   = 4 // orig name in States[0]
+)
+
+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) {
+	str := make([]byte, 0, 32)
+	for {
+		c, err := data.ReadByte()
+		if err != nil {
+			return "", err
+		}
+		switch {
+		case c == 0 || c == ' ':
+			return string(str), nil
+		case c >= 'a' && c <= 'f':
+		case c >= 'A' && c <= 'F':
+		case c >= '0' && c <= '9':
+		default:
+			return "", errors.New("Invalid character in hex string:" + string(c))
+		}
+		str = append(str, c)
+	}
+}
+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()
+		if err != nil {
+			return "", errors.New("Unexpected EOF. Expected NUL string term")
+		}
+		if c == 0 {
+			return string(str), nil
+		}
+		str = append(str, c)
+	}
+}
+
+func skipGitStatusEntry(data io.ByteReader, skipSpaceLen int) error {
+	for skipSpaceLen > 0 {
+		c, err := data.ReadByte()
+		if err != nil {
+			return err
+		}
+		if c == ' ' {
+			skipSpaceLen--
+		}
+	}
+
+	return nil
+}
+
+func parseSingleStatusEntry(data io.ByteReader) (*GitStatusData, error) {
+	ret := GitStatusData{}
+	statusType, err := data.ReadByte()
+	if err != nil {
+		return nil, nil
+	}
+	switch statusType {
+	case '1':
+		var err error
+		if err = skipGitStatusEntry(data, 8); err != nil {
+			return nil, err
+		}
+		ret.Status = GitStatus_Modified
+		ret.Path, err = parseGitStatusStringWithSpace(data)
+		if err != nil {
+			return nil, err
+		}
+	case '2':
+		var err error
+		if err = skipGitStatusEntry(data, 9); err != nil {
+			return nil, err
+		}
+		ret.Status = GitStatus_Renamed
+		ret.Path, err = parseGitStatusStringWithSpace(data)
+		if err != nil {
+			return nil, err
+		}
+		ret.States[0], err = parseGitStatusStringWithSpace(data)
+		if err != nil {
+			return nil, err
+		}
+	case '?':
+		var err error
+		if err = skipGitStatusEntry(data, 1); err != nil {
+			return nil, err
+		}
+		ret.Status = GitStatus_Untracked
+		ret.Path, err = parseGitStatusStringWithSpace(data)
+		if err != nil {
+			return nil, err
+		}
+	case '!':
+		var err error
+		if err = skipGitStatusEntry(data, 1); err != nil {
+			return nil, err
+		}
+		ret.Status = GitStatus_Ignored
+		ret.Path, err = parseGitStatusStringWithSpace(data)
+		if err != nil {
+			return nil, err
+		}
+	case 'u':
+		var err error
+		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
+		}
+		if ret.States[1], err = parseGitStatusHexString(data); err != nil {
+			return nil, err
+		}
+		if ret.States[2], err = parseGitStatusHexString(data); err != nil {
+			return nil, err
+		}
+		ret.Status = GitStatus_Unmerged
+		ret.Path, err = parseGitStatusStringWithSpace(data)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, errors.New("Invalid status type" + string(statusType))
+	}
+	return &ret, nil
+}
+
+func parseGitStatusData(data io.ByteReader) ([]GitStatusData, error) {
+	ret := make([]GitStatusData, 0, 10)
+	for {
+		data, err := parseSingleStatusEntry(data)
+		if err != nil {
+			return nil, err
+		} else if data == nil {
+			break
+		}
+
+		ret = append(ret, *data)
+	}
+	return ret, nil
+}
+
+func (e *GitHandlerImpl) GitStatus(cwd string) (ret []GitStatusData, err error) {
+	LogDebug("getting git-status()")
+
+	cmd := exec.Command("/usr/bin/git", "status", "--porcelain=2", "-z")
 	cmd.Env = []string{
 		"GIT_CEILING_DIRECTORIES=" + e.GitPath,
 		"GIT_LFS_SKIP_SMUDGE=1",
@@ -1033,12 +1209,7 @@ func (e *GitHandlerImpl) GitExecWithDataParse(cwd string, dataprocessor func(io.
 		LogError("Error running command", cmd.Args, err)
 	}

-	return dataprocessor(bytes.NewReader(out))
-}
-
-func (e *GitHandlerImpl) GitStatus(cwd string) (ret []GitStatusData, err error) {
-	data, err := e.GitExecWithDataParse(cwd, parseGitStatusData, "status", "--porcelain=2", "-z")
-	return data.([]GitStatusData), err
+	return parseGitStatusData(bufio.NewReader(bytes.NewReader(out)))
 }

 func (e *GitHandlerImpl) GitDiff(cwd, base, head string) (string, error) {
@@ -1063,122 +1234,3 @@ func (e *GitHandlerImpl) GitDiff(cwd, base, head string) (string, error) {

 	return string(out), nil
 }
-
-func (e *GitHandlerImpl) GitDiffIndex(cwd, commit string) ([]GitDiffRawData, error) {
-	data, err := e.GitExecWithDataParse("diff-index", parseGitDiffIndexRawData, cwd, "diff-index", "-z", "--raw", "--full-index", "--submodule=short", "HEAD")
-	return data.([]GitDiffRawData), err
-}
-
-func (git *GitHandlerImpl) GitResolveConflicts(cwd, mergeBase, head, mergeHead string) error {
-	status, err := git.GitStatus(cwd)
-	if err != nil {
-		return fmt.Errorf("Status failed: %w", err)
-	}
-
-	// we can only resolve conflicts with .gitmodules
-	for _, s := range status {
-		if s.Status == GitStatus_Unmerged && s.Path == ".gitmodules" {
-			if err := git.GitResolveSubmoduleFileConflict(s, cwd, mergeBase, head, mergeHead); err != nil {
-				return err
-			}
-		} else if s.Status == GitStatus_Unmerged {
-			return fmt.Errorf("Cannot automatically resolve conflict: %s", s.Path)
-		}
-	}
-
-	return git.GitExec(cwd, "-c", "core.editor=true", "merge", "--continue")
-}
-
-func (git *GitHandlerImpl) GitResolveSubmoduleFileConflict(s GitStatusData, cwd, mergeBase, head, mergeHead string) error {
-	submodules1, err := git.GitSubmoduleList(cwd, mergeBase)
-	if err != nil {
-		return fmt.Errorf("Failed to fetch submodules during merge resolution: %w", err)
-	}
-	/*
-		submodules2, err := git.GitSubmoduleList(cwd, head)
-		if err != nil {
-			return fmt.Errorf("Failed to fetch submodules during merge resolution: %w", err)
-		}
-	*/
-	submodules3, err := git.GitSubmoduleList(cwd, mergeHead)
-	if err != nil {
-		return fmt.Errorf("Failed to fetch submodules during merge resolution: %w", err)
-	}
-
-	// find modified submodules in the mergeHead
-	modifiedSubmodules := make([]string, 0, 10)
-	removedSubmodules := make([]string, 0, 10)
-	addedSubmodules := make([]string, 0, 10)
-
-	for submodulePath, oldHash := range submodules1 {
-		if newHash, found := submodules3[submodulePath]; found && newHash != oldHash {
-			modifiedSubmodules = append(modifiedSubmodules, submodulePath)
-		} else if !found {
-			removedSubmodules = append(removedSubmodules, submodulePath)
-		}
-	}
-	for submodulePath, _ := range submodules3 {
-		if _, found := submodules1[submodulePath]; !found {
-			addedSubmodules = append(addedSubmodules, submodulePath)
-		}
-	}
-
-	// We need to adjust the `submodules` list by the pending changes to the index
-	s1, err := git.GitExecWithOutput(cwd, "cat-file", "blob", s.States[0])
-	if err != nil {
-		return fmt.Errorf("Failed fetching data during .gitmodules merge resoulution: %w", err)
-	}
-	s2, err := git.GitExecWithOutput(cwd, "cat-file", "blob", s.States[1])
-	if err != nil {
-		return fmt.Errorf("Failed fetching data during .gitmodules merge resoulution: %w", err)
-	}
-	s3, err := git.GitExecWithOutput(cwd, "cat-file", "blob", s.States[2])
-	if err != nil {
-		return fmt.Errorf("Failed fetching data during .gitmodules merge resoulution: %w", err)
-	}
-
-	_, err = ParseSubmodulesFile(strings.NewReader(s1))
-	if err != nil {
-		return fmt.Errorf("Failed parsing submodule file [%s] in merge: %w", s.States[0], err)
-	}
-	subs2, err := ParseSubmodulesFile(strings.NewReader(s2))
-	if err != nil {
-		return fmt.Errorf("Failed parsing submodule file [%s] in merge: %w", s.States[0], err)
-	}
-	subs3, err := ParseSubmodulesFile(strings.NewReader(s3))
-	if err != nil {
-		return fmt.Errorf("Failed parsing submodule file [%s] in merge: %w", s.States[0], err)
-	}
-
-	overrideSet := make([]Submodule, 0, len(addedSubmodules)+len(modifiedSubmodules))
-	for i := range subs3 {
-		if slices.Contains(addedSubmodules, subs3[i].Path) || slices.Contains(modifiedSubmodules, subs3[i].Path) {
-			overrideSet = append(overrideSet, subs3[i])
-		}
-	}
-	// merge from subs1 (merge-base), subs2 (changes in base since merge-base HEAD), subs3 (merge_source MERGE_HEAD)
-	// this will update submodules
-	SubmoduleCompare := func(a, b Submodule) int { return strings.Compare(a.Path, b.Path) }
-	CompactCompare := func(a, b Submodule) bool { return a.Path == b.Path }
-
-	// remove submodules that are removed in the PR
-	subs2 = slices.DeleteFunc(subs2, func(a Submodule) bool { return slices.Contains(removedSubmodules, a.Path) })
-
-	mergedSubs := slices.Concat(overrideSet, subs2)
-	slices.SortStableFunc(mergedSubs, SubmoduleCompare)
-	filteredSubs := slices.CompactFunc(mergedSubs, CompactCompare)
-
-	out, err := os.Create(path.Join(git.GetPath(), cwd, ".gitmodules"))
-	if err != nil {
-		return fmt.Errorf("Can't open .gitmodules for writing: %w", err)
-	}
-	if err = WriteSubmodules(filteredSubs, out); err != nil {
-		return fmt.Errorf("Can't write .gitmodules: %w", err)
-	}
-	if out.Close(); err != nil {
-		return fmt.Errorf("Can't close .gitmodules: %w", err)
-	}
-
-	git.GitExecOrPanic(cwd, "add", ".gitmodules")
-	return nil
-}
--- a/common/git_utils_test.go
+++ b/common/git_utils_test.go
@@ -24,7 +24,6 @@ import (
 	"os"
 	"os/exec"
 	"path"
-	"runtime/debug"
 	"slices"
 	"strings"
 	"testing"
@@ -94,145 +93,6 @@ func TestGitClone(t *testing.T) {
 	}
 }

-func TestSubmoduleConflictResolution(t *testing.T) {
-	tests := []struct {
-		name            string
-		checkout, merge string
-		result          string
-		merge_fail      bool
-	}{
-		{
-			name:     "adding two submodules",
-			checkout: "base_add_b1",
-			merge:    "base_add_b2",
-			result: `[submodule "pkgA"]
-	path = pkgA
-	url = ../pkgA
-[submodule "pkgB"]
-	path = pkgB
-	url = ../pkgB
-[submodule "pkgB1"]
-	path = pkgB1
-	url = ../pkgB1
-[submodule "pkgB2"]
-	path = pkgB2
-	url = ../pkgB2
-[submodule "pkgC"]
-	path = pkgC
-	url = ../pkgC
-`,
-		},
-		{
-			name:     "remove one module and add another",
-			checkout: "base_rm_c",
-			merge:    "base_add_b2",
-			result: `[submodule "pkgA"]
-	path = pkgA
-	url = ../pkgA
-[submodule "pkgB"]
-	path = pkgB
-	url = ../pkgB
-[submodule "pkgB2"]
-	path = pkgB2
-	url = ../pkgB2
-`,
-		},
-		{
-			name:     "add one and remove another",
-			checkout: "base_add_b2",
-			merge:    "base_rm_c",
-			result: `[submodule "pkgA"]
-	path = pkgA
-	url = ../pkgA
-[submodule "pkgB"]
-	path = pkgB
-	url = ../pkgB
-[submodule "pkgB2"]
-	path = pkgB2
-	url = ../pkgB2
-`,
-		},
-		{
-			name:       "rm modified submodule",
-			checkout:   "base_modify_c",
-			merge:      "base_rm_c",
-			merge_fail: true,
-		},
-		{
-			name:       "modified removed submodule",
-			checkout:   "base_rm_c",
-			merge:      "base_modify_c",
-			merge_fail: true,
-		},
-	}
-
-	d, err := os.MkdirTemp(os.TempDir(), "submoduletests")
-	if err != nil {
-		t.Fatal(err)
-	}
-	cwd, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	cmd := exec.Command(cwd + "/test_repo_setup.sh")
-	cmd.Dir = d
-	_, err = cmd.Output()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gh, err := AllocateGitWorkTree(d, "test", "foo@example.com")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	success := true
-	noErrorOrFail := func(t *testing.T, err error) {
-		if err != nil {
-			t.Fatal(string(debug.Stack()), err)
-		}
-	}
-	for _, test := range tests {
-		success = t.Run(test.name, func(t *testing.T) {
-			git, err := gh.ReadExistingPath("prjgit")
-			defer git.Close()
-
-			if err != nil {
-				t.Fatal(err)
-			}
-			noErrorOrFail(t, git.GitExec("", "reset", "--hard"))
-			noErrorOrFail(t, git.GitExec("", "checkout", "-B", "test", test.checkout))
-			//			noErrorOrFail(t, git.GitExec("", "merge", test.checkout))
-			err = git.GitExec("", "merge", test.merge)
-			if err == nil {
-				t.Fatal("expected a conflict")
-			}
-			err = git.GitResolveConflicts("", "main", test.checkout, test.merge)
-			if err != nil {
-				if test.merge_fail {
-					return // success
-				}
-				t.Fatal(err)
-			}
-			if test.merge_fail {
-				t.Fatal("Expected fail but succeeded?")
-			}
-			data, err := os.ReadFile(git.GetPath() + "/.gitmodules")
-			if err != nil {
-				t.Fatal("Cannot read .gitmodules.", err)
-			}
-
-			if string(data) != test.result {
-				t.Error("Expected", len(test.result), test.result, "but have", len(data), string(data))
-			}
-		}) && success
-	}
-
-	if success {
-		os.RemoveAll(d)
-	}
-}
-
 func TestGitMsgParsing(t *testing.T) {
 	t.Run("tree message with size 56", func(t *testing.T) {
 		const hdr = "f40888ea4515fe2e8eea617a16f5f50a45f652d894de3ad181d58de3aafb8f98 tree 56\x00"
@@ -724,15 +584,12 @@ func TestGitStatusParse(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-
-			res := r.([]GitStatusData)
-
-			if len(res) != len(test.res) {
-				t.Fatal("len(r):", len(res), "is not expected", len(test.res))
+			if len(r) != len(test.res) {
+				t.Fatal("len(r):", len(r), "is not expected", len(test.res))
 			}

 			for _, expected := range test.res {
-				if !slices.Contains(res, expected) {
+				if !slices.Contains(r, expected) {
 					t.Fatal("result", r, "doesn't contains expected", expected)
 				}
 			}
--- a/common/gitea_utils.go
+++ b/common/gitea_utils.go
@@ -29,6 +29,7 @@ import (
 	"path"
 	"path/filepath"
 	"slices"
+	"sync"
 	"time"

 	transport "github.com/go-openapi/runtime/client"
@@ -66,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)
 }
@@ -182,6 +191,8 @@ type Gitea interface {
 	GiteaCommitStatusGetter
 	GiteaCommitStatusSetter
 	GiteaSetRepoOptions
+	GiteaLabelGetter
+	GiteaLabelSettter

 	GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error)
 	GetDoneNotifications(Type string, page int64) ([]*models.NotificationThread, error)
@@ -189,7 +200,7 @@ type Gitea interface {
 	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)
+	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)
@@ -466,6 +477,30 @@ func (gitea *GiteaTransport) SetRepoOptions(owner, repo string, manual_merge boo
 	return ok.Payload, err
 }

+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
+}
+
+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
+	}
+
+	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 ret.Payload, nil
+}
+
 const (
 	GiteaNotificationType_Pull = "Pull"
 )
@@ -643,7 +678,7 @@ 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:  targetId,
 		Head:  srcId,
@@ -659,7 +694,7 @@ func (gitea *GiteaTransport) CreatePullRequestIfNotExist(repo *models.Repository
 			WithHead(srcId),
 		gitea.transport.DefaultAuthentication,
 	); err == nil && pr.Payload.State == "open" {
-		return pr.Payload, nil
+		return pr.Payload, nil, false
 	}

 	pr, err := gitea.client.Repository.RepoCreatePullRequest(
@@ -673,10 +708,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
+	return pr.GetPayload(), nil, true
 }

 func (gitea *GiteaTransport) RequestReviews(pr *models.PullRequest, reviewers ...string) ([]*models.PullReview, error) {
@@ -763,45 +798,78 @@ 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
+
 func (gitea *GiteaTransport) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) {
 	page := int64(1)
 	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
+		}
+
+		// 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 {
-		res, err := gitea.client.Issue.IssueGetCommentsAndTimeline(
-			issue.NewIssueGetCommentsAndTimelineParams().
-				WithOwner(org).
-				WithRepo(repo).
-				WithIndex(idx).
-				WithPage(&page),
-			gitea.transport.DefaultAuthentication,
-		)
-
+		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 = len(res.Payload)
-		LogDebug("page:", page, "len:", resCount)
-		if resCount == 0 {
+		if resCount = len(res.Payload); resCount == 0 {
 			break
 		}
-		page++

 		for _, d := range res.Payload {
 			if d != nil {
-				retData = append(retData, d)
+				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++
 	}
-	LogDebug("total results:", len(retData))
-	slices.SortFunc(retData, func(a, b *models.TimelineComment) int {
+	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) {
--- a/common/mock/gitea_utils.go
+++ b/common/mock/gitea_utils.go
@@ -18,6 +18,132 @@ import (
 	models "src.opensuse.org/autogits/common/gitea-generated/models"
 )

+// MockGiteaLabelGetter is a mock of GiteaLabelGetter interface.
+type MockGiteaLabelGetter struct {
+	ctrl     *gomock.Controller
+	recorder *MockGiteaLabelGetterMockRecorder
+	isgomock struct{}
+}
+
+// MockGiteaLabelGetterMockRecorder is the mock recorder for MockGiteaLabelGetter.
+type MockGiteaLabelGetterMockRecorder struct {
+	mock *MockGiteaLabelGetter
+}
+
+// NewMockGiteaLabelGetter creates a new mock instance.
+func NewMockGiteaLabelGetter(ctrl *gomock.Controller) *MockGiteaLabelGetter {
+	mock := &MockGiteaLabelGetter{ctrl: ctrl}
+	mock.recorder = &MockGiteaLabelGetterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockGiteaLabelGetter) EXPECT() *MockGiteaLabelGetterMockRecorder {
+	return m.recorder
+}
+
+// GetLabels mocks base method.
+func (m *MockGiteaLabelGetter) GetLabels(org, repo string, idx int64) ([]*models.Label, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLabels", org, repo, idx)
+	ret0, _ := ret[0].([]*models.Label)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLabels indicates an expected call of GetLabels.
+func (mr *MockGiteaLabelGetterMockRecorder) GetLabels(org, repo, idx any) *MockGiteaLabelGetterGetLabelsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLabels", reflect.TypeOf((*MockGiteaLabelGetter)(nil).GetLabels), org, repo, idx)
+	return &MockGiteaLabelGetterGetLabelsCall{Call: call}
+}
+
+// MockGiteaLabelGetterGetLabelsCall wrap *gomock.Call
+type MockGiteaLabelGetterGetLabelsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockGiteaLabelGetterGetLabelsCall) Return(arg0 []*models.Label, arg1 error) *MockGiteaLabelGetterGetLabelsCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockGiteaLabelGetterGetLabelsCall) Do(f func(string, string, int64) ([]*models.Label, error)) *MockGiteaLabelGetterGetLabelsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockGiteaLabelGetterGetLabelsCall) DoAndReturn(f func(string, string, int64) ([]*models.Label, error)) *MockGiteaLabelGetterGetLabelsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// MockGiteaLabelSettter is a mock of GiteaLabelSettter interface.
+type MockGiteaLabelSettter struct {
+	ctrl     *gomock.Controller
+	recorder *MockGiteaLabelSettterMockRecorder
+	isgomock struct{}
+}
+
+// MockGiteaLabelSettterMockRecorder is the mock recorder for MockGiteaLabelSettter.
+type MockGiteaLabelSettterMockRecorder struct {
+	mock *MockGiteaLabelSettter
+}
+
+// NewMockGiteaLabelSettter creates a new mock instance.
+func NewMockGiteaLabelSettter(ctrl *gomock.Controller) *MockGiteaLabelSettter {
+	mock := &MockGiteaLabelSettter{ctrl: ctrl}
+	mock.recorder = &MockGiteaLabelSettterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockGiteaLabelSettter) EXPECT() *MockGiteaLabelSettterMockRecorder {
+	return m.recorder
+}
+
+// SetLabels mocks base method.
+func (m *MockGiteaLabelSettter) SetLabels(org, repo string, idx int64, labels []string) ([]*models.Label, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetLabels", org, repo, idx, labels)
+	ret0, _ := ret[0].([]*models.Label)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetLabels indicates an expected call of SetLabels.
+func (mr *MockGiteaLabelSettterMockRecorder) SetLabels(org, repo, idx, labels any) *MockGiteaLabelSettterSetLabelsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLabels", reflect.TypeOf((*MockGiteaLabelSettter)(nil).SetLabels), org, repo, idx, labels)
+	return &MockGiteaLabelSettterSetLabelsCall{Call: call}
+}
+
+// MockGiteaLabelSettterSetLabelsCall wrap *gomock.Call
+type MockGiteaLabelSettterSetLabelsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockGiteaLabelSettterSetLabelsCall) Return(arg0 []*models.Label, arg1 error) *MockGiteaLabelSettterSetLabelsCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockGiteaLabelSettterSetLabelsCall) Do(f func(string, string, int64, []string) ([]*models.Label, error)) *MockGiteaLabelSettterSetLabelsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockGiteaLabelSettterSetLabelsCall) DoAndReturn(f func(string, string, int64, []string) ([]*models.Label, error)) *MockGiteaLabelSettterSetLabelsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // MockGiteaTimelineFetcher is a mock of GiteaTimelineFetcher interface.
 type MockGiteaTimelineFetcher struct {
 	ctrl     *gomock.Controller
@@ -1850,12 +1976,13 @@ func (c *MockGiteaAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest,
 }

 // CreatePullRequestIfNotExist mocks base method.
-func (m *MockGitea) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error) {
+func (m *MockGitea) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreatePullRequestIfNotExist", repo, srcId, targetId, title, body)
 	ret0, _ := ret[0].(*models.PullRequest)
 	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	ret2, _ := ret[2].(bool)
+	return ret0, ret1, ret2
 }

 // CreatePullRequestIfNotExist indicates an expected call of CreatePullRequestIfNotExist.
@@ -1871,19 +1998,19 @@ type MockGiteaCreatePullRequestIfNotExistCall struct {
 }

 // Return rewrite *gomock.Call.Return
-func (c *MockGiteaCreatePullRequestIfNotExistCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaCreatePullRequestIfNotExistCall {
-	c.Call = c.Call.Return(arg0, arg1)
+func (c *MockGiteaCreatePullRequestIfNotExistCall) Return(arg0 *models.PullRequest, arg1 error, arg2 bool) *MockGiteaCreatePullRequestIfNotExistCall {
+	c.Call = c.Call.Return(arg0, arg1, arg2)
 	return c
 }

 // Do rewrite *gomock.Call.Do
-func (c *MockGiteaCreatePullRequestIfNotExistCall) Do(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall {
+func (c *MockGiteaCreatePullRequestIfNotExistCall) Do(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error, bool)) *MockGiteaCreatePullRequestIfNotExistCall {
 	c.Call = c.Call.Do(f)
 	return c
 }

 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockGiteaCreatePullRequestIfNotExistCall) DoAndReturn(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall {
+func (c *MockGiteaCreatePullRequestIfNotExistCall) DoAndReturn(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error, bool)) *MockGiteaCreatePullRequestIfNotExistCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -2202,6 +2329,45 @@ func (c *MockGiteaGetIssueCommentsCall) DoAndReturn(f func(string, string, int64
 	return c
 }

+// GetLabels mocks base method.
+func (m *MockGitea) GetLabels(org, repo string, idx int64) ([]*models.Label, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLabels", org, repo, idx)
+	ret0, _ := ret[0].([]*models.Label)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLabels indicates an expected call of GetLabels.
+func (mr *MockGiteaMockRecorder) GetLabels(org, repo, idx any) *MockGiteaGetLabelsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLabels", reflect.TypeOf((*MockGitea)(nil).GetLabels), org, repo, idx)
+	return &MockGiteaGetLabelsCall{Call: call}
+}
+
+// MockGiteaGetLabelsCall wrap *gomock.Call
+type MockGiteaGetLabelsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockGiteaGetLabelsCall) Return(arg0 []*models.Label, arg1 error) *MockGiteaGetLabelsCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockGiteaGetLabelsCall) Do(f func(string, string, int64) ([]*models.Label, error)) *MockGiteaGetLabelsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockGiteaGetLabelsCall) DoAndReturn(f func(string, string, int64) ([]*models.Label, error)) *MockGiteaGetLabelsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // GetNotifications mocks base method.
 func (m *MockGitea) GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error) {
 	m.ctrl.T.Helper()
@@ -2793,6 +2959,45 @@ func (c *MockGiteaSetCommitStatusCall) DoAndReturn(f func(string, string, string
 	return c
 }

+// SetLabels mocks base method.
+func (m *MockGitea) SetLabels(org, repo string, idx int64, labels []string) ([]*models.Label, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetLabels", org, repo, idx, labels)
+	ret0, _ := ret[0].([]*models.Label)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetLabels indicates an expected call of SetLabels.
+func (mr *MockGiteaMockRecorder) SetLabels(org, repo, idx, labels any) *MockGiteaSetLabelsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLabels", reflect.TypeOf((*MockGitea)(nil).SetLabels), org, repo, idx, labels)
+	return &MockGiteaSetLabelsCall{Call: call}
+}
+
+// MockGiteaSetLabelsCall wrap *gomock.Call
+type MockGiteaSetLabelsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockGiteaSetLabelsCall) Return(arg0 []*models.Label, arg1 error) *MockGiteaSetLabelsCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockGiteaSetLabelsCall) Do(f func(string, string, int64, []string) ([]*models.Label, error)) *MockGiteaSetLabelsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockGiteaSetLabelsCall) DoAndReturn(f func(string, string, int64, []string) ([]*models.Label, error)) *MockGiteaSetLabelsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // SetNotificationRead mocks base method.
 func (m *MockGitea) SetNotificationRead(notificationId int64) error {
 	m.ctrl.T.Helper()
--- a/common/pr.go
+++ b/common/pr.go
@@ -4,6 +4,8 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
+	"os"
+	"path"
 	"slices"
 	"strings"

@@ -231,10 +233,11 @@ next_rs:
 		}

 		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
@@ -291,7 +294,7 @@ func (rs *PRSet) AssignReviewers(gitea GiteaReviewFetcherAndRequester, maintaine
 			if !IsDryRun {
 				for _, r := range reviewers {
 					if _, err := gitea.RequestReviews(pr.PR, r); err != nil {
-						LogError("Cannot create reviews on", fmt.Sprintf("%s/%s!%d for [%s]", pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index, strings.Join(reviewers, ", ")), err)
+						LogError("Cannot create reviews on", fmt.Sprintf("%s/%s!%d for [%s]", pr.PR.Base.Repo.Owner.UserName, pr.PR.Base.Repo.Name, pr.PR.Index, r), err)
 					}
 				}
 			}
@@ -431,8 +434,80 @@ func (rs *PRSet) Merge(gitea GiteaReviewUnrequester, git Git) error {

 	err = git.GitExec(DefaultGitPrj, "merge", "--no-ff", "-m", msg, prjgit.Head.Sha)
 	if err != nil {
-		if resolveError := git.GitResolveConflicts(DefaultGitPrj, prjgit.MergeBase, prjgit.Base.Sha, prjgit.Head.Sha); resolveError != nil {
-			return fmt.Errorf("Merge failed. (%w): %w", err, resolveError)
+		status, statusErr := git.GitStatus(DefaultGitPrj)
+		if statusErr != nil {
+			return fmt.Errorf("Failed to merge: %w . Status also failed: %w", err, statusErr)
+		}
+
+		// 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
+				}
+
+				submodules, err := git.GitSubmoduleList(DefaultGitPrj, "MERGE_HEAD")
+				if err != nil {
+					return fmt.Errorf("Failed to fetch submodules during merge resolution: %w", err)
+				}
+				s1, err := git.GitExecWithOutput(DefaultGitPrj, "cat-file", "blob", s.States[0])
+				if err != nil {
+					return fmt.Errorf("Failed fetching data during .gitmodules merge resoulution: %w", err)
+				}
+				s2, err := git.GitExecWithOutput(DefaultGitPrj, "cat-file", "blob", s.States[1])
+				if err != nil {
+					return fmt.Errorf("Failed fetching data during .gitmodules merge resoulution: %w", err)
+				}
+				s3, err := git.GitExecWithOutput(DefaultGitPrj, "cat-file", "blob", s.States[2])
+				if err != nil {
+					return fmt.Errorf("Failed fetching data during .gitmodules merge resoulution: %w", err)
+				}
+
+				subs1, err := ParseSubmodulesFile(strings.NewReader(s1))
+				if err != nil {
+					return fmt.Errorf("Failed parsing submodule file [%s] in merge: %w", s.States[0], err)
+				}
+				subs2, err := ParseSubmodulesFile(strings.NewReader(s2))
+				if err != nil {
+					return fmt.Errorf("Failed parsing submodule file [%s] in merge: %w", s.States[0], err)
+				}
+				subs3, err := ParseSubmodulesFile(strings.NewReader(s3))
+				if err != nil {
+					return fmt.Errorf("Failed parsing submodule file [%s] in merge: %w", s.States[0], err)
+				}
+
+				// merge from subs3 (target), subs1 (orig), subs2 (2-nd base that is missing from target base)
+				// this will update submodules
+				mergedSubs := slices.Concat(subs1, subs2, subs3)
+
+				var filteredSubs []Submodule = make([]Submodule, 0, max(len(subs1), len(subs2), len(subs3)))
+			nextSub:
+				for subName := range submodules {
+
+					for i := range mergedSubs {
+						if path.Base(mergedSubs[i].Path) == subName {
+							filteredSubs = append(filteredSubs, mergedSubs[i])
+							continue nextSub
+						}
+					}
+					return fmt.Errorf("Cannot find submodule for path: %s", subName)
+				}
+
+				out, err := os.Create(path.Join(git.GetPath(), DefaultGitPrj, ".gitmodules"))
+				if err != nil {
+					return fmt.Errorf("Can't open .gitmodules for writing: %w", err)
+				}
+				if err = WriteSubmodules(filteredSubs, out); err != nil {
+					return fmt.Errorf("Can't write .gitmodules: %w", err)
+				}
+				if out.Close(); err != nil {
+					return fmt.Errorf("Can't close .gitmodules: %w", err)
+				}
+
+				git.GitExecOrPanic(DefaultGitPrj, "add", ".gitmodules")
+				git.GitExecOrPanic(DefaultGitPrj, "-c", "core.editor=true", "merge", "--continue")
+			}
 		}
 	}

--- a/common/pr_test.go
+++ b/common/pr_test.go
@@ -15,23 +15,22 @@ import (
 	"src.opensuse.org/autogits/common/gitea-generated/models"
 	mock_common "src.opensuse.org/autogits/common/mock"
 )
-
 /*
-	func TestCockpit(t *testing.T) {
-		common.SetLoggingLevel(common.LogLevelDebug)
-		gitea := common.AllocateGiteaTransport("https://src.opensuse.org")
-		tl, err := gitea.GetTimeline("cockpit", "cockpit", 29)
-		if err != nil {
-			t.Fatal("Fail to timeline", err)
-		}
-		t.Log(tl)
-		r, err := common.FetchGiteaReviews(gitea, []string{}, "cockpit", "cockpit", 29)
-		if err != nil {
-			t.Fatal("Error:", err)
-		}
-
-		t.Error(r)
+func TestCockpit(t *testing.T) {
+	common.SetLoggingLevel(common.LogLevelDebug)
+	gitea := common.AllocateGiteaTransport("https://src.opensuse.org")
+	tl, err := gitea.GetTimeline("cockpit", "cockpit", 29)
+	if err != nil {
+		t.Fatal("Fail to timeline", err)
 	}
+	t.Log(tl)
+	r, err := common.FetchGiteaReviews(gitea, []string{}, "cockpit", "cockpit", 29)
+	if err != nil {
+		t.Fatal("Error:", err)
+	}
+
+	t.Error(r)
+}
 */
 func reviewsToTimeline(reviews []*models.PullReview) []*models.TimelineComment {
 	timeline := make([]*models.TimelineComment, len(reviews))
@@ -941,7 +940,6 @@ func TestPRMerge(t *testing.T) {
 			pr: &models.PullRequest{
 				Base: &models.PRBranchInfo{
 					Sha: "e8b0de43d757c96a9d2c7101f4bff404e322f53a1fa4041fb85d646110c38ad4", // "base_add_b1"
-					Name: "master",
 					Repo: &models.Repository{
 						Name: "prj",
 						Owner: &models.User{
@@ -962,7 +960,6 @@ func TestPRMerge(t *testing.T) {
 			pr: &models.PullRequest{
 				Base: &models.PRBranchInfo{
 					Sha: "4fbd1026b2d7462ebe9229a49100c11f1ad6555520a21ba515122d8bc41328a8",
-					Name: "master",
 					Repo: &models.Repository{
 						Name: "prj",
 						Owner: &models.User{
@@ -982,7 +979,6 @@ func TestPRMerge(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			ctl := gomock.NewController(t)
 			mock := mock_common.NewMockGiteaPRTimelineFetcher(ctl)
-
 			reviewUnrequestMock := mock_common.NewMockGiteaReviewUnrequester(ctl)

 			reviewUnrequestMock.EXPECT().UnrequestReview(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
--- a/common/test_repo_setup.sh
+++ b/common/test_repo_setup.sh
@@ -40,24 +40,10 @@ create_prjgit_sample() {
 	git submodule -q add ../pkgB2 pkgB2
 	git commit -q -m "pkgB2 added"

-	git checkout -b base_rm_c main
+	git checkout main
 	git clean -ffxd
-	git rm pkgC
-	git commit -q -m 'pkgC removed'
-
-	git checkout -b base_modify_c main
-	git submodule update --init pkgC
-	pushd pkgC
-	echo "mofieid" >> README.md
-	git commit -q -m "modified" README.md
-	popd
-	git commit pkgC -m "modifiedC"
-	git submodule deinit -f pkgC
-
-#	git checkout main
-#	git clean -ffxd
-#	git submodule -q add -f ../pkgB1 pkgB1
-#	git commit -q -m "main adding pkgB1"
+	git submodule -q add -f ../pkgB1 pkgB1
+	git commit -q -m "main adding pkgB1"

 	popd
 }
--- a/common/utils.go
+++ b/common/utils.go
@@ -168,9 +168,10 @@ func FetchDevelProjects() (DevelProjects, error) {
 }

 var DevelProjectNotFound = errors.New("Devel project not found")
+
 func (d DevelProjects) GetDevelProject(pkg string) (string, error) {
 	for _, item := range d {
-	if item.Package == pkg {
+		if item.Package == pkg {
 			return item.Project, nil
 		}
 	}
@@ -178,3 +179,33 @@ func (d DevelProjects) GetDevelProject(pkg string) (string, error) {
 	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
+}
--- a/common/utils_test.go
+++ b/common/utils_test.go
@@ -165,3 +165,58 @@ 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)
+			}
+		})
+	}
+}
--- a/devel-importer/find_factory_commit.pl
+++ b/devel-importer/find_factory_commit.pl
@@ -58,6 +58,30 @@ sub ListPackages {
    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]]";
@@ -65,6 +89,7 @@ sub Usage {

 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);
@@ -139,7 +164,7 @@ if ( scalar @tomove > 0 ) {
        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 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";
+        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";
    }
 }

@@ -167,6 +192,7 @@ for my $package ( sort(@packages) ) {
      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) {
@@ -179,16 +205,27 @@ for my $package ( sort(@packages) ) {
                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 system(
-"cd $package; osc ls -v openSUSE:Factory $package | awk '{print \$1 FS \$7}' | grep -v -F '_scmsync.obsinfo\nbuild.specials.obscpio' | md5sum -c --quiet"
-            ) == 0
-            and system("bash -c \"diff <(ls -1 $package | sort) <(osc ls openSUSE:Factory $package | grep -v -F '_scmsync.obsinfo\nbuild.specials.obscpio' | sort)\"") == 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;
+	    }

-            $c     = $commit;
-            $match = 1;
-            last;
        }
    }

--- a/gitea_status_proxy/main.go
+++ b/gitea_status_proxy/main.go
@@ -14,15 +14,11 @@ import (
 	"src.opensuse.org/autogits/common"
 )

-type Status struct {
-	Context   string `json:"context"`
-	State     string `json:"state"`
-	TargetUrl string `json:"target_url"`
-}
-
 type StatusInput struct {
-	State     string `json:"state"`
-	TargetUrl string `json:"target_url"`
+	Description string `json:"description"`
+	Context     string `json:"context"`
+	State       string `json:"state"`
+	TargetUrl   string `json:"target_url"`
 }

 func main() {
@@ -59,23 +55,26 @@ func StatusProxy(w http.ResponseWriter, r *http.Request) {
 		config, ok := r.Context().Value(configKey).(*Config)

 		if !ok {
-			common.LogError("Config missing from context")
+			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], "Bearer") {
+		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
 		}
@@ -83,6 +82,7 @@ func StatusProxy(w http.ResponseWriter, r *http.Request) {
 		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
 		}
@@ -104,13 +104,8 @@ func StatusProxy(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 			return
 		}
-		status := Status{
-			Context:   "Build in obs",
-			State:     statusinput.State,
-			TargetUrl: statusinput.TargetUrl,
-		}

-		status_payload, err := json.Marshal(status)
+		status_payload, err := json.Marshal(statusinput)

 		if err != nil {
 			http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
@@ -131,8 +126,8 @@ func StatusProxy(w http.ResponseWriter, r *http.Request) {
 			return
 		}

-		req.Header.Add("Content-Type", "Content-Type")
-		req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", ForgeToken))
+		req.Header.Add("Content-Type", "application/json")
+		req.Header.Add("Authorization", fmt.Sprintf("token %s", ForgeToken))

 		resp, err := client.Do(req)

--- a/gitea_status_proxy/readme.md
+++ b/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
--- a/group-review/main.go
+++ b/group-review/main.go
@@ -149,7 +149,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 {
--- a/obs-staging-bot/main.go
+++ b/obs-staging-bot/main.go
@@ -386,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
@@ -1044,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)

--- a/obs-status-service/README.md
+++ b/obs-status-service/README.md
@@ -1,7 +1,10 @@
 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:

@@ -17,19 +20,32 @@ 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
 -------
@@ -42,3 +58,4 @@ Default parameters can be changed by env variables
 | `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
--- a/obs-status-service/svg.go
+++ b/obs-status-service/svg.go
@@ -6,6 +6,7 @@ import (
 	"html"
 	"net/url"
 	"slices"
+	"strings"
 )

 type SvgWriter struct {
@@ -133,7 +134,7 @@ func (svg *SvgWriter) WritePackageStatus(loglink, arch, status, detail string) {
 }

 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(repo) + "=1")
+	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
 	}
--- a/systemd/workflow-direct@.service
+++ b/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
+
--- a/utils/gitmodules-automerge/README.md
+++ b/utils/gitmodules-automerge/README.md
@@ -1,9 +0,0 @@
-Purpose
-------
-
-Automatically resolve git configlicts in .gitmodules if there's a conflict
-due to a merge.
-
-It uses HEAD and MERGE_HEAD to calculate merge base and pass it to the
-conflict resolution
-
--- a/utils/gitmodules-automerge/main.go
+++ b/utils/gitmodules-automerge/main.go
@@ -1,42 +0,0 @@
-package main
-
-import (
-	"os"
-	"strings"
-
-	"src.opensuse.org/autogits/common"
-)
-
-func main() {
-	cwd, err := os.Getwd()
-	if err != nil {
-		common.LogError(err)
-		return
-	}
-	gh, err := common.AllocateGitWorkTree(cwd, "", "")
-	if err != nil {
-		common.LogError(err)
-		return
-	}
-
-	git, err := gh.ReadExistingPath("")
-	if err != nil {
-		common.LogError(err)
-		return
-	}
-
-	MergeBase := strings.TrimSpace(git.GitExecWithOutputOrPanic("", "merge-base", "HEAD", "MERGE_HEAD"))
-	status, err := git.GitStatus("")
-	if err != nil {
-		common.LogError(err)
-		return
-	}
-
-	for _, s := range status {
-		if s.Path == ".gitmodules" && s.Status == common.GitStatus_Unmerged {
-			if err := git.GitResolveSubmoduleFileConflict(s, "", MergeBase, "HEAD", "MERGE_HEAD"); err != nil {
-				common.LogError(err)
-			}
-		}
-	}
-}
--- a/workflow-direct/README.md
+++ b/workflow-direct/README.md
@@ -10,9 +10,6 @@ Areas of responsibility
   * on repository adds, creates a new submodule (if non empty)
   * on repository removal, removes the submodule

-NOTE: reverts (push HEAD^) are not supported as they would step-on the
-work of the workflow-pr bot. Manual update of the project git is
-required in this case.

 Configuration
 -------------
@@ -26,6 +23,20 @@ Uses `workflow.config` for configuration. Parameters

 NOTE: `-rm`, `-removed`, `-deleted` are all removed suffixes used to indicate current branch is a placeholder for previously existing package. These branches will be ignored by the bot,  and if default, the package will be removed and will not be added to the project.

+Running
+-------
+
+ * `GITEA_TOKEN` (required)
+ * `AMQP_USERNAME` (required)
+ * `AMQP_PASSWORD` (required)
+ * `AUTOGITS_CONFIG` (required)
+ * `AUTOGITS_URL` - default: https://src.opensuse.org
+ * `AUTOGITS_RABBITURL` - default: amqps://rabbit.opensuse.org
+ * `AUTOGITS_DEBUG` - disabled by default, set to any value to enable
+ * `AUTOGITS_CHECK_ON_START` - disabled by default, set to any value to enable
+ * `AUTOGITS_REPO_PATH` - default is temporary directory
+ * `AUTOGITS_IDENTITY_FILE` - in case where we need explicit identify path for ssh specified
+
 Target Usage
 ------------

--- a/workflow-direct/main.go
+++ b/workflow-direct/main.go
@@ -22,7 +22,6 @@ import (
 	"flag"
 	"fmt"
 	"io/fs"
-	"log"
 	"math/rand"
 	"net/url"
 	"os"
@@ -40,7 +39,7 @@ import (
 const (
 	AppName   = "direct_workflow"
 	GitAuthor = "AutoGits prjgit-updater"
-	GitEmail  = "adam+autogits-direct@zombino.com"
+	GitEmail  = "autogits-direct@noreply@src.opensuse.org"
 )

 var configuredRepos map[string][]*common.AutogitConfig
@@ -53,18 +52,6 @@ func isConfiguredOrg(org *common.Organization) bool {
 	return found
 }

-func concatenateErrors(err1, err2 error) error {
-	if err1 == nil {
-		return err2
-	}
-
-	if err2 == nil {
-		return err1
-	}
-
-	return fmt.Errorf("%w\n%w", err1, err2)
-}
-
 type RepositoryActionProcessor struct{}

 func (*RepositoryActionProcessor) ProcessFunc(request *common.Request) error {
@@ -72,38 +59,43 @@ func (*RepositoryActionProcessor) ProcessFunc(request *common.Request) error {
 	configs, configFound := configuredRepos[action.Organization.Username]

 	if !configFound {
-		log.Printf("Repository event for %s. Not configured. Ignoring.\n", action.Organization.Username)
+		common.LogInfo("Repository event for", action.Organization.Username, ". Not configured. Ignoring.", action.Organization.Username)
 		return nil
 	}

 	for _, config := range configs {
 		if org, repo, _ := config.GetPrjGit(); org == action.Repository.Owner.Username && repo == action.Repository.Name {
-			log.Println("+ ignoring repo event for PrjGit repository", config.GitProjectName)
+			common.LogError("+ ignoring repo event for PrjGit repository", config.GitProjectName)
 			return nil
 		}
 	}

-	var err error
 	for _, config := range configs {
-		err = concatenateErrors(err, processConfiguredRepositoryAction(action, config))
+		processConfiguredRepositoryAction(action, config)
 	}

-	return err
+	return nil
 }

-func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, config *common.AutogitConfig) error {
+func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, config *common.AutogitConfig) {
 	gitOrg, gitPrj, gitBranch := config.GetPrjGit()
 	git, err := gh.CreateGitHandler(config.Organization)
 	common.PanicOnError(err)
 	defer git.Close()

-	if len(config.Branch) == 0 {
-		config.Branch = action.Repository.Default_Branch
+	configBranch := config.Branch
+	if len(configBranch) == 0 {
+		configBranch = action.Repository.Default_Branch
+		if common.IsRemovedBranch(configBranch) {
+			common.LogDebug("   - default branch has deleted suffix. Skipping")
+			return
+		}
 	}

 	prjGitRepo, err := gitea.CreateRepositoryIfNotExist(git, gitOrg, gitPrj)
 	if err != nil {
-		return fmt.Errorf("Error accessing/creating prjgit: %s/%s#%s err: %w", gitOrg, gitPrj, gitBranch, err)
+		common.LogError("Error accessing/creating prjgit:", gitOrg, gitPrj, gitBranch, err)
+		return
 	}

 	remoteName, err := git.GitClone(gitPrj, gitBranch, prjGitRepo.SSHURL)
@@ -112,29 +104,29 @@ func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, co
 	switch action.Action {
 	case "created":
 		if action.Repository.Object_Format_Name != "sha256" {
-			return fmt.Errorf("   - '%s' repo is not sha256. Ignoring.", action.Repository.Name)
+			common.LogError("   - ", action.Repository.Name, "repo is not sha256. Ignoring.")
+			return
 		}
 		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--depth", "1", action.Repository.Clone_Url, action.Repository.Name))
-		defer git.GitExecOrPanic(gitPrj, "submodule", "deinit", "--all")
+		defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all", "-f")

 		branch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, action.Repository.Name), "branch", "--show-current"))
-		if branch != config.Branch {
-			if err := git.GitExec(path.Join(gitPrj, action.Repository.Name), "fetch", "--depth", "1", "origin", config.Branch+":"+config.Branch); err != nil {
-				return fmt.Errorf("error fetching branch %s. ignoring as non-existent. err: %w", config.Branch, err) // no branch? so ignore repo here
+		if branch != configBranch {
+			if err := git.GitExec(path.Join(gitPrj, action.Repository.Name), "fetch", "--depth", "1", "origin", configBranch+":"+configBranch); err != nil {
+				common.LogError("error fetching branch", configBranch, ". ignoring as non-existent.", err) // no branch? so ignore repo here
+				return
 			}
-			common.PanicOnError(git.GitExec(path.Join(gitPrj, action.Repository.Name), "checkout", config.Branch))
+			common.PanicOnError(git.GitExec(path.Join(gitPrj, action.Repository.Name), "checkout", configBranch))
 		}
-		common.PanicOnError(git.GitExec(gitPrj, "commit", "-m", "Automatic package inclusion via Direct Workflow"))
+		common.PanicOnError(git.GitExec(gitPrj, "commit", "-m", "Auto-inclusion "+action.Repository.Name))
 		if !noop {
 			common.PanicOnError(git.GitExec(gitPrj, "push"))
 		}

 	case "deleted":
 		if stat, err := os.Stat(filepath.Join(git.GetPath(), gitPrj, action.Repository.Name)); err != nil || !stat.IsDir() {
-			if DebugMode {
-				log.Println("delete event for", action.Repository.Name, "-- not in project. Ignoring")
-			}
-			return nil
+			common.LogDebug("delete event for", action.Repository.Name, "-- not in project. Ignoring")
+			return
 		}
 		common.PanicOnError(git.GitExec(gitPrj, "rm", action.Repository.Name))
 		common.PanicOnError(git.GitExec(gitPrj, "commit", "-m", "Automatic package removal via Direct Workflow"))
@@ -143,10 +135,9 @@ func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, co
 		}

 	default:
-		return fmt.Errorf("%s: %s", "Unknown action type", action.Action)
+		common.LogError("Unknown action type:", action.Action)
+		return
 	}
-
-	return nil
 }

 type PushActionProcessor struct{}
@@ -156,40 +147,44 @@ func (*PushActionProcessor) ProcessFunc(request *common.Request) error {
 	configs, configFound := configuredRepos[action.Repository.Owner.Username]

 	if !configFound {
-		log.Printf("Repository event for %s. Not configured. Ignoring.\n", action.Repository.Owner.Username)
+		common.LogDebug("Repository event for", action.Repository.Owner.Username, ". Not configured. Ignoring.")
 		return nil
 	}

 	for _, config := range configs {
 		if gitOrg, gitPrj, _ := config.GetPrjGit(); gitOrg == action.Repository.Owner.Username && gitPrj == action.Repository.Name {
-			log.Println("+ ignoring push to PrjGit repository", config.GitProjectName)
+			common.LogInfo("+ ignoring push to PrjGit repository", config.GitProjectName)
 			return nil
 		}
 	}

-	var err error
 	for _, config := range configs {
-		err = concatenateErrors(err, processConfiguredPushAction(action, config))
+		processConfiguredPushAction(action, config)
 	}
-
-	return err
+	return nil
 }

-func processConfiguredPushAction(action *common.PushWebhookEvent, config *common.AutogitConfig) error {
+func processConfiguredPushAction(action *common.PushWebhookEvent, config *common.AutogitConfig) {
 	gitOrg, gitPrj, gitBranch := config.GetPrjGit()
 	git, err := gh.CreateGitHandler(config.Organization)
 	common.PanicOnError(err)
 	defer git.Close()

-	log.Printf("push to: %s/%s for %s/%s#%s", action.Repository.Owner.Username, action.Repository.Name, gitOrg, gitPrj, gitBranch)
-	if len(config.Branch) == 0 {
-		config.Branch = action.Repository.Default_Branch
-		log.Println("  + default branch", action.Repository.Default_Branch)
+	common.LogDebug("push to:", action.Repository.Owner.Username, action.Repository.Name, "for:", gitOrg, gitPrj, gitBranch)
+	branch := config.Branch
+	if len(branch) == 0 {
+		if common.IsRemovedBranch(branch) {
+			common.LogDebug("  + default branch has removed suffix:", branch, "Skipping.")
+			return
+		}
+		branch = action.Repository.Default_Branch
+		common.LogDebug("  + using default branch", branch)
 	}

 	prjGitRepo, err := gitea.CreateRepositoryIfNotExist(git, gitOrg, gitPrj)
 	if err != nil {
-		return fmt.Errorf("Error accessing/creating prjgit: %s/%s err: %w", gitOrg, gitPrj, err)
+		common.LogError("Error accessing/creating prjgit:", gitOrg, gitPrj, err)
+		return
 	}

 	remoteName, err := git.GitClone(gitPrj, gitBranch, prjGitRepo.SSHURL)
@@ -198,23 +193,25 @@ func processConfiguredPushAction(action *common.PushWebhookEvent, config *common
 	common.PanicOnError(err)
 	commit, ok := git.GitSubmoduleCommitId(gitPrj, action.Repository.Name, headCommitId)
 	for ok && action.Head_Commit.Id == commit {
-		log.Println("  -- nothing to do, commit already in ProjectGit")
-		return nil
+		common.LogDebug("  -- nothing to do, commit already in ProjectGit")
+		return
 	}

-	if stat, err := os.Stat(filepath.Join(git.GetPath(), gitPrj, action.Repository.Name)); err != nil || !stat.IsDir() {
-		if DebugMode {
-			log.Println("Pushed to package that is not part of the project. Ignoring:", err)
-		}
-		return nil
+	if stat, err := os.Stat(filepath.Join(git.GetPath(), gitPrj, action.Repository.Name)); err != nil {
+		git.GitExecOrPanic(gitPrj, "submodule", "--quiet", "add", "--depth", "1", action.Repository.Clone_Url, action.Repository.Name)
+		common.LogDebug("Pushed to package that is not part of the project. Re-adding...", err)
+	} else if !stat.IsDir() {
+		common.LogError("Pushed to a package that is not a submodule but exists in the project. Ignoring.")
+		return
 	}
 	git.GitExecOrPanic(gitPrj, "submodule", "update", "--init", "--depth", "1", "--checkout", action.Repository.Name)
-	defer git.GitExecOrPanic(gitPrj, "submodule", "deinit", "--all")
+	defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all", "-f")

-	if err := git.GitExec(filepath.Join(gitPrj, action.Repository.Name), "fetch", "--depth", "1", "--force", remoteName, config.Branch+":"+config.Branch); err != nil {
-		return fmt.Errorf("error fetching branch %s. ignoring as non-existent. err: %w", config.Branch, err) // no branch? so ignore repo here
+	if err := git.GitExec(filepath.Join(gitPrj, action.Repository.Name), "fetch", "--depth", "1", "--force", "origin", branch+":"+branch); err != nil {
+		common.LogError("Error fetching branch:", branch, "Ignoring as non-existent.", err)
+		return
 	}
-	id, err := git.GitRemoteHead(filepath.Join(gitPrj, action.Repository.Name), remoteName, config.Branch)
+	id, err := git.GitRemoteHead(filepath.Join(gitPrj, action.Repository.Name), "origin", branch)
 	common.PanicOnError(err)
 	if action.Head_Commit.Id == id {
 		git.GitExecOrPanic(filepath.Join(gitPrj, action.Repository.Name), "checkout", id)
@@ -222,11 +219,10 @@ func processConfiguredPushAction(action *common.PushWebhookEvent, config *common
 		if !noop {
 			git.GitExecOrPanic(gitPrj, "push", remoteName)
 		}
-		return nil
+		return
 	}

-	log.Println("push of refs not on the configured branch", config.Branch, ". ignoring.")
-	return nil
+	common.LogDebug("push of refs not on the configured branch", branch, ". ignoring.")
 }

 func verifyProjectState(git common.Git, org string, config *common.AutogitConfig, configs []*common.AutogitConfig) (err error) {
@@ -248,51 +244,64 @@ func verifyProjectState(git common.Git, org string, config *common.AutogitConfig

 	remoteName, err := git.GitClone(gitPrj, gitBranch, repo.SSHURL)
 	common.PanicOnError(err)
-	defer git.GitExecOrPanic(gitPrj, "submodule", "deinit", "--all")
+	defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all", "-f")

-	log.Println("   * Getting submodule list")
+	common.LogDebug("   * Getting submodule list")
 	sub, err := git.GitSubmoduleList(gitPrj, "HEAD")
 	common.PanicOnError(err)

-	log.Println("   * Getting package links")
+	common.LogDebug("   * Getting package links")
 	var pkgLinks []*PackageRebaseLink
 	if f, err := fs.Stat(os.DirFS(path.Join(git.GetPath(), gitPrj)), common.PrjLinksFile); err == nil && (f.Mode()&fs.ModeType == 0) && f.Size() < 1000000 {
 		if data, err := os.ReadFile(path.Join(git.GetPath(), gitPrj, common.PrjLinksFile)); err == nil {
 			pkgLinks, err = parseProjectLinks(data)
 			if err != nil {
-				log.Println("Cannot parse project links file:", err.Error())
+				common.LogError("Cannot parse project links file:", err.Error())
 				pkgLinks = nil
 			} else {
 				ResolveLinks(org, pkgLinks, gitea)
 			}
 		}
 	} else {
-		log.Println("   - No package links defined")
+		common.LogInfo("   - No package links defined")
 	}

 	/* Check existing submodule that they are updated */
-
 	isGitUpdated := false
 next_package:
 	for filename, commitId := range sub {
 		// ignore project gits
 		//for _, c := range configs {
 		if gitPrj == filename {
-			log.Println("     prjgit as package? ignoring project git:", filename)
+			common.LogDebug("     prjgit as package? ignoring project git:", filename)
 			continue next_package
 		}
 		//}

-		log.Printf("     verifying package: %s -> %s(%s)", commitId, filename, config.Branch)
-		commits, err := gitea.GetRecentCommits(org, filename, config.Branch, 10)
-		if len(commits) == 0 {
-			if repo, err := gitea.GetRepository(org, filename); repo == nil && err == nil {
+		branch := config.Branch
+		common.LogDebug("     verifying package:", commitId, "->", filename, "@", branch)
+		if repo, err := gitea.GetRepository(org, filename); repo == nil && err == nil {
+			common.LogDebug("       repository removed...")
+			git.GitExecOrPanic(gitPrj, "rm", filename)
+			isGitUpdated = true
+			continue
+		} else if err != nil {
+			common.LogError("failed fetching repo data", org, filename, err)
+			continue
+		} else if len(branch) == 0 {
+			branch = repo.DefaultBranch
+			common.LogDebug("      -> using default branch", branch)
+			if common.IsRemovedBranch(branch) {
+				common.LogDebug("      Default branch for", filename, "is excluded")
 				git.GitExecOrPanic(gitPrj, "rm", filename)
 				isGitUpdated = true
+				continue
 			}
 		}
+
+		commits, err := gitea.GetRecentCommits(org, filename, branch, 10)
 		if err != nil {
-			log.Println("   -> failed to fetch recent commits for package:", filename, " Err:", err)
+			common.LogDebug("   -> failed to fetch recent commits for package:", filename, " Err:", err)
 			continue
 		}

@@ -309,7 +318,7 @@ next_package:
 			if l.Pkg == filename {
 				link = l

-				log.Println("      -> linked package")
+				common.LogDebug("      -> linked package")
 				// so, we need to rebase here. Can't really optimize, so clone entire package tree and remote
 				pkgPath := path.Join(gitPrj, filename)
 				git.GitExecOrPanic(gitPrj, "submodule", "update", "--init", "--checkout", filename)
@@ -323,7 +332,7 @@ next_package:
 				nCommits := len(common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgPath, "rev-list", "^NOW", "HEAD"), "\n"))
 				if nCommits > 0 {
 					if !noop {
-						git.GitExecOrPanic(pkgPath, "push", "-f", "origin", "HEAD:"+config.Branch)
+						git.GitExecOrPanic(pkgPath, "push", "-f", "origin", "HEAD:"+branch)
 					}
 					isGitUpdated = true
 				}
@@ -340,42 +349,27 @@ next_package:
 				common.PanicOnError(git.GitExec(gitPrj, "submodule", "update", "--init", "--depth", "1", "--checkout", filename))
 				common.PanicOnError(git.GitExec(filepath.Join(gitPrj, filename), "fetch", "--depth", "1", "origin", commits[0].SHA))
 				common.PanicOnError(git.GitExec(filepath.Join(gitPrj, filename), "checkout", commits[0].SHA))
-				log.Println("    -> updated to", commits[0].SHA)
+				common.LogDebug("    -> updated to", commits[0].SHA)
 				isGitUpdated = true
 			} else {
 				// probably need `merge-base` or `rev-list` here instead, or the project updated already
-				log.Println("     *** Cannot find SHA of last matching update for package:", filename, " Ignoring")
+				common.LogInfo("     *** Cannot find SHA of last matching update for package:", filename, " Ignoring")
 			}
 		}
 	}

 	// find all missing repositories, and add them
-	if DebugMode {
-		log.Println("checking for missing repositories...")
-	}
+	common.LogDebug("checking for missing repositories...")
 	repos, err := gitea.GetOrganizationRepositories(org)
 	if err != nil {
 		return err
 	}

-	if DebugMode {
-		log.Println("  nRepos:", len(repos))
-	}
+	common.LogDebug("  nRepos:", len(repos))

 	/* Check repositories in org to make sure they are included in project git */
 next_repo:
 	for _, r := range repos {
-		if DebugMode {
-			log.Println(" -- checking", r.Name)
-		}
-
-		if r.ObjectFormatName != "sha256" {
-			if DebugMode {
-				log.Println("    + ", r.ObjectFormatName, ". Needs to be sha256. Ignoring")
-			}
-			continue next_repo
-		}
-
 		//		for _, c := range configs {
 		if gitPrj == r.Name {
 			// ignore project gits
@@ -390,27 +384,32 @@ next_repo:
 			}
 		}

-		if DebugMode {
-			log.Println(" -- checking repository:", r.Name)
-		}
+		common.LogDebug(" -- checking repository:", r.Name)

-		if _, err := gitea.GetRecentCommits(org, r.Name, config.Branch, 1); err != nil {
+		branch := config.Branch
+		if len(branch) == 0 {
+			branch = r.DefaultBranch
+			if common.IsRemovedBranch(branch) {
+				continue
+			}
+		}
+		if commits, err := gitea.GetRecentCommits(org, r.Name, branch, 1); err != nil || len(commits) == 0 {
 			// assumption that package does not exist, so not part of project
 			// https://github.com/go-gitea/gitea/issues/31976
+
+			// or, we do not have commits here
 			continue
 		}

 		// add repository to git project
 		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--depth", "1", r.CloneURL, r.Name))

-		if len(config.Branch) > 0 {
-			branch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, r.Name), "branch", "--show-current"))
-			if branch != config.Branch {
-				if err := git.GitExec(path.Join(gitPrj, r.Name), "fetch", "--depth", "1", "origin", config.Branch+":"+config.Branch); err != nil {
-					return fmt.Errorf("Fetching branch %s for %s/%s failed. Ignoring.", config.Branch, repo.Owner.UserName, r.Name)
-				}
-				common.PanicOnError(git.GitExec(path.Join(gitPrj, r.Name), "checkout", config.Branch))
+		curBranch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, r.Name), "branch", "--show-current"))
+		if branch != curBranch {
+			if err := git.GitExec(path.Join(gitPrj, r.Name), "fetch", "--depth", "1", "origin", branch+":"+branch); err != nil {
+				return fmt.Errorf("Fetching branch %s for %s/%s failed. Ignoring.", branch, repo.Owner.UserName, r.Name)
 			}
+			common.PanicOnError(git.GitExec(path.Join(gitPrj, r.Name), "checkout", branch))
 		}

 		isGitUpdated = true
@@ -423,10 +422,7 @@ next_repo:
 		}
 	}

-	if DebugMode {
-		log.Println("Verification finished for ", org, ", prjgit:", config.GitProjectName)
-	}
-
+	common.LogInfo("Verification finished for ", org, ", prjgit:", config.GitProjectName)
 	return nil
 }

@@ -437,17 +433,17 @@ var checkInterval time.Duration
 func checkOrg(org string, configs []*common.AutogitConfig) {
 	git, err := gh.CreateGitHandler(org)
 	if err != nil {
-		log.Println("Faield to allocate GitHandler:", err)
+		common.LogError("Failed to allocate GitHandler:", err)
 		return
 	}
 	defer git.Close()

 	for _, config := range configs {
-		log.Printf(" ++ starting verification, org: `%s` config: `%s`\n", org, config.GitProjectName)
+		common.LogInfo(" ++ starting verification, org:", org, "config:", config.GitProjectName)
 		if err := verifyProjectState(git, org, config, configs); err != nil {
-			log.Printf(" *** verification failed, org: `%s`, err: %#v\n", org, err)
+			common.LogError(" *** verification failed, org:", org, err)
 		} else {
-			log.Printf(" ++ verification complete, org: `%s` config: `%s`\n", org, config.GitProjectName)
+			common.LogError(" ++ verification complete, org:", org, config.GitProjectName)
 		}
 	}
 }
@@ -456,7 +452,7 @@ func checkRepos() {
 	for org, configs := range configuredRepos {
 		if checkInterval > 0 {
 			sleepInterval := checkInterval - checkInterval/2 + time.Duration(rand.Int63n(int64(checkInterval)))
-			log.Println(" - sleep interval", sleepInterval, "until next check")
+			common.LogInfo(" - sleep interval", sleepInterval, "until next check")
 			time.Sleep(sleepInterval)
 		}

@@ -468,9 +464,9 @@ func consistencyCheckProcess() {
 	if checkOnStart {
 		savedCheckInterval := checkInterval
 		checkInterval = 0
-		log.Println("== Startup consistency check begin...")
+		common.LogInfo("== Startup consistency check begin...")
 		checkRepos()
-		log.Println("== Startup consistency check done...")
+		common.LogInfo("== Startup consistency check done...")
 		checkInterval = savedCheckInterval
 	}

@@ -485,7 +481,8 @@ var gh common.GitHandlerGenerator
 func updateConfiguration(configFilename string, orgs *[]string) {
 	configFile, err := common.ReadConfigFile(configFilename)
 	if err != nil {
-		log.Fatal(err)
+		common.LogError(err)
+		os.Exit(4)
 	}

 	configs, _ := common.ResolveWorkflowConfigs(gitea, configFile)
@@ -493,9 +490,7 @@ func updateConfiguration(configFilename string, orgs *[]string) {
 	*orgs = make([]string, 0, 1)
 	for _, c := range configs {
 		if slices.Contains(c.Workflows, "direct") {
-			if DebugMode {
-				log.Printf("  + adding org: '%s', branch: '%s', prjgit: '%s'\n", c.Organization, c.Branch, c.GitProjectName)
-			}
+			common.LogDebug("  + adding org:", c.Organization, ", branch:", c.Branch, ", prjgit:", c.GitProjectName)
 			configs := configuredRepos[c.Organization]
 			if configs == nil {
 				configs = make([]*common.AutogitConfig, 0, 1)
@@ -509,7 +504,7 @@ func updateConfiguration(configFilename string, orgs *[]string) {
 }

 func main() {
-	configFilename := flag.String("config", "", "List of PrjGit")
+	configFilename := flag.String("config", "config.json", "List of PrjGit")
 	giteaUrl := flag.String("gitea-url", "https://src.opensuse.org", "Gitea instance")
 	rabbitUrl := flag.String("url", "amqps://rabbit.opensuse.org", "URL for RabbitMQ instance")
 	flag.BoolVar(&DebugMode, "debug", false, "Extra debugging information")
@@ -520,10 +515,35 @@ func main() {
 	flag.Parse()

 	if err := common.RequireGiteaSecretToken(); err != nil {
-		log.Fatal(err)
+		common.LogError(err)
+		os.Exit(1)
 	}
 	if err := common.RequireRabbitSecrets(); err != nil {
-		log.Fatal(err)
+		common.LogError(err)
+		os.Exit(1)
+	}
+
+	if cf := os.Getenv("AUTOGITS_CONFIG"); len(cf) > 0 {
+		*configFilename = cf
+	}
+	if url := os.Getenv("AUTOGITS_URL"); len(url) > 0 {
+		*giteaUrl = url
+	}
+	if url := os.Getenv("AUTOGITS_RABBITURL"); len(url) > 0 {
+		*rabbitUrl = url
+	}
+	if debug := os.Getenv("AUTOGITS_DEBUG"); len(debug) > 0 {
+		DebugMode = true
+	}
+	if check := os.Getenv("AUTOGITS_CHECK_ON_START"); len(check) > 0 {
+		checkOnStart = true
+	}
+	if p := os.Getenv("AUTOGITS_REPO_PATH"); len(p) > 0 {
+		*basePath = p
+	}
+
+	if DebugMode {
+		common.SetLoggingLevel(common.LogLevelDebug)
 	}

 	defs := &common.RabbitMQGiteaEventsProcessor{}
@@ -532,12 +552,14 @@ func main() {
 	if len(*basePath) == 0 {
 		*basePath, err = os.MkdirTemp(os.TempDir(), AppName)
 		if err != nil {
-			log.Fatal(err)
+			common.LogError(err)
+			os.Exit(1)
 		}
 	}
 	gh, err = common.AllocateGitWorkTree(*basePath, GitAuthor, GitEmail)
 	if err != nil {
-		log.Fatal(err)
+		common.LogError(err)
+		os.Exit(1)
 	}

 	// handle reconfiguration
@@ -552,10 +574,10 @@ func main() {
 			}

 			if sig != syscall.SIGHUP {
-				log.Println("Unexpected signal received:", sig)
+				common.LogError("Unexpected signal received:", sig)
 				continue
 			}
-			log.Println("*** Reconfiguring ***")
+			common.LogError("*** Reconfiguring ***")
 			updateConfiguration(*configFilename, &defs.Orgs)
 			defs.Connection().UpdateTopics(defs)
 		}
@@ -567,23 +589,25 @@ func main() {
 	gitea = common.AllocateGiteaTransport(*giteaUrl)
 	CurrentUser, err := gitea.GetCurrentUser()
 	if err != nil {
-		log.Fatalln("Cannot fetch current user:", err)
+		common.LogError("Cannot fetch current user:", err)
+		os.Exit(2)
 	}
-	log.Println("Current User:", CurrentUser.UserName)
+	common.LogInfo("Current User:", CurrentUser.UserName)

 	updateConfiguration(*configFilename, &defs.Orgs)

 	defs.Connection().RabbitURL, err = url.Parse(*rabbitUrl)
 	if err != nil {
-		log.Panicf("cannot parse server URL. Err: %#v\n", err)
+		common.LogError("cannot parse server URL. Err:", err)
+		os.Exit(3)
 	}

 	go consistencyCheckProcess()
-	log.Println("defs:", *defs)
+	common.LogInfo("defs:", *defs)

 	defs.Handlers = make(map[string]common.RequestProcessor)
 	defs.Handlers[common.RequestType_Push] = &PushActionProcessor{}
 	defs.Handlers[common.RequestType_Repository] = &RepositoryActionProcessor{}

-	log.Fatal(common.ProcessRabbitMQEvents(defs))
+	common.LogError(common.ProcessRabbitMQEvents(defs))
 }
--- a/workflow-pr/README.md
+++ b/workflow-pr/README.md
@@ -35,6 +35,7 @@ JSON
 * _ReviewRequired_: (true, false) ignores that submitter is a maintainer and require a review from other maintainer IFF available
 * _NoProjectGitPR_: (true, false) do not create PrjGit PRs, but still process reviews, etc.
 * _Permissions_: permissions and associated accounts/groups. See below.
+* _Labels_: (string, string) Labels for PRs. See below.

 NOTE: `-rm`, `-removed`, `-deleted` are all removed suffixes used to indicate current branch is a placeholder for previously existing package. These branches will be ignored by the bot,  and if default, the package will be removed and will not be added to the project.
 example:
@@ -74,6 +75,18 @@ results in
 * moo -> package and project reviews, but ignored


+Labels
+------
+
+The following labels are used, when defined in Repo/Org.
+
+| Label Config Entry | Default label  | Description
+|--------------------|----------------|----------------------------------------
+| StagingAuto        | staging/Auto   | Assigned to Project Git PRs when first staged
+| ReviewPending      | review/Pending | Assigned to PR when reviews are still pending
+| ReviewDone         | review/Done    | Assigned to PR when reviews are complete on this particular PR
+
+
 Maintainership
 --------------

--- a/workflow-pr/interfaces/state_checker.go
+++ b/workflow-pr/interfaces/state_checker.go
@@ -7,7 +7,7 @@ import "src.opensuse.org/autogits/common"

 type StateChecker interface {
 	VerifyProjectState(configs *common.AutogitConfig) ([]*PRToProcess, error)
-	CheckRepos() error
+	CheckRepos()
 	ConsistencyCheckProcess() error
 }

--- a/workflow-pr/pr_processor.go
+++ b/workflow-pr/pr_processor.go
@@ -227,12 +227,18 @@ func (pr *PRProcessor) CreatePRjGitPR(prjGitPRbranch string, prset *common.PRSet
 		}

 		title, desc := PrjGitDescription(prset)
-		pr, err := Gitea.CreatePullRequestIfNotExist(PrjGit, prjGitPRbranch, PrjGitBranch, title, desc)
+		pr, err, isNew := Gitea.CreatePullRequestIfNotExist(PrjGit, prjGitPRbranch, PrjGitBranch, title, desc)
 		if err != nil {
 			common.LogError("Error creating PrjGit PR:", err)
 			return err
 		}
-		Gitea.UpdatePullRequest(PrjGit.Owner.UserName, PrjGit.Name, pr.Index, &models.EditPullRequestOption{
+		org := PrjGit.Owner.UserName
+		repo := PrjGit.Name
+		idx := pr.Index
+		if isNew {
+			Gitea.SetLabels(org, repo, idx, []string{prset.Config.Label(common.Label_StagingAuto)})
+		}
+		Gitea.UpdatePullRequest(org, repo, idx, &models.EditPullRequestOption{
 			RemoveDeadline: true,
 		})

@@ -269,6 +275,7 @@ func (pr *PRProcessor) RebaseAndSkipSubmoduleCommits(prset *common.PRSet, branch
 }

 var updatePrjGitError_requeue error = errors.New("Commits do not match. Requeing after 5 seconds.")
+
 func (pr *PRProcessor) UpdatePrjGitPR(prset *common.PRSet) error {
 	_, _, PrjGitBranch := prset.Config.GetPrjGit()
 	PrjGitPR, err := prset.GetPrjGitPR()
@@ -381,6 +388,10 @@ func (pr *PRProcessor) Process(req *models.PullRequest) error {
 	prjGitPRbranch := prGitBranchNameForPR(prRepo, prNo)
 	prjGitPR, err := prset.GetPrjGitPR()
 	if err == common.PRSet_PrjGitMissing {
+		if req.State != "open" {
+			common.LogDebug("This PR is closed and no ProjectGit PR. Ignoring.")
+			return nil
+		}
 		common.LogDebug("Missing PrjGit. Need to create one under branch", prjGitPRbranch)

 		if err = pr.CreatePRjGitPR(prjGitPRbranch, prset); err != nil {
@@ -572,7 +583,7 @@ func (pr *PRProcessor) Process(req *models.PullRequest) error {

 type RequestProcessor struct {
 	configuredRepos map[string][]*common.AutogitConfig
-	recursive int
+	recursive       int
 }

 func ProcesPullRequest(pr *models.PullRequest, configs []*common.AutogitConfig) error {
@@ -613,7 +624,7 @@ func (w *RequestProcessor) ProcessFunc(request *common.Request) (err error) {
 			common.LogError("Cannot find PR for issue:", req.Pull_Request.Base.Repo.Owner.Username, req.Pull_Request.Base.Repo.Name, req.Pull_Request.Number)
 			return err
 		}
-	} else if req, ok := request.Data.(*common.IssueWebhookEvent); ok {
+	} else if req, ok := request.Data.(*common.IssueCommentWebhookEvent); ok {
 		pr, err = Gitea.GetPullRequest(req.Repository.Owner.Username, req.Repository.Name, int64(req.Issue.Number))
 		if err != nil {
 			common.LogError("Cannot find PR for issue:", req.Repository.Owner.Username, req.Repository.Name, int64(req.Issue.Number))
--- a/workflow-pr/pr_processor_opened_test.go
+++ b/workflow-pr/pr_processor_opened_test.go
@@ -103,7 +103,7 @@ func TestOpenPR(t *testing.T) {
 		}
 		// gitea.EXPECT().GetAssociatedPrjGitPR("test", "prjcopy", "test", "testRepo", int64(1)).Return(nil, nil)
 		gitea.EXPECT().CreateRepositoryIfNotExist(git, "test", "prjcopy").Return(prjgit, nil)
-		gitea.EXPECT().CreatePullRequestIfNotExist(prjgit, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(giteaPR, nil)
+		gitea.EXPECT().CreatePullRequestIfNotExist(prjgit, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(giteaPR, nil, true)
 		gitea.EXPECT().GetPullRequest("test", "testRepo", int64(1)).Return(giteaPR, nil)
 		gitea.EXPECT().RequestReviews(giteaPR, "reviewer1", "reviewer2").Return(nil, nil)
 		gitea.EXPECT().GetPullRequestReviews("test", "testRepo", int64(0)).Return([]*models.PullReview{}, nil)
@@ -153,7 +153,7 @@ func TestOpenPR(t *testing.T) {
 		}
 		failedErr := errors.New("Returned error here")
 		gitea.EXPECT().CreateRepositoryIfNotExist(git, "test", "prjcopy").Return(prjgit, nil)
-		gitea.EXPECT().CreatePullRequestIfNotExist(prjgit, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, failedErr)
+		gitea.EXPECT().CreatePullRequestIfNotExist(prjgit, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, failedErr, false)

 		err := pr.Process(event)
 		if err != failedErr {
@@ -193,7 +193,7 @@ func TestOpenPR(t *testing.T) {
 		gitea.EXPECT().CreateRepositoryIfNotExist(git, "test", "prjcopy").Return(prjgit, nil)
 		gitea.EXPECT().GetPullRequest("test", "testRepo", int64(1)).Return(giteaPR, nil)
 		gitea.EXPECT().GetPullRequestReviews("org", "SomeRepo", int64(13)).Return([]*models.PullReview{}, nil)
-		gitea.EXPECT().CreatePullRequestIfNotExist(prjgit, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(giteaPR, nil)
+		gitea.EXPECT().CreatePullRequestIfNotExist(prjgit, gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(giteaPR, nil, true)
 		gitea.EXPECT().RequestReviews(giteaPR, "reviewer1", "reviewer2").Return(nil, failedErr)

 		gitea.EXPECT().FetchMaintainershipDirFile("test", "prjcopy", "branch", "_project").Return(nil, "", repository.NewRepoGetRawFileNotFound())
--- a/workflow-pr/repo_check.go
+++ b/workflow-pr/repo_check.go
@@ -1,7 +1,6 @@
 package main

 import (
-	"errors"
 	"fmt"
 	"math/rand"
 	"path"
@@ -43,6 +42,15 @@ func pullRequestToEventState(state models.StateType) string {
 }

 func (s *DefaultStateChecker) ProcessPR(pr *models.PullRequest, config *common.AutogitConfig) error {
+	defer func() {
+		if r := recover(); r != nil {
+			common.LogError("panic caught in ProcessPR", common.PRtoString(pr))
+			if err, ok := r.(error); !ok {
+				common.LogError(err)
+			}
+			common.LogError(string(debug.Stack()))
+		}
+	}()
 	return ProcesPullRequest(pr, common.AutogitConfigs{config})
 }

@@ -151,7 +159,7 @@ func (s *DefaultStateChecker) VerifyProjectState(config *common.AutogitConfig) (
 	return PrjGitSubmoduleCheck(config, git, prjGitRepo, submodules)
 }

-func (s *DefaultStateChecker) CheckRepos() error {
+func (s *DefaultStateChecker) CheckRepos() {
 	defer func() {
 		if r := recover(); r != nil {
 			common.LogError("panic caught")
@@ -161,7 +169,6 @@ func (s *DefaultStateChecker) CheckRepos() error {
 			common.LogError(string(debug.Stack()))
 		}
 	}()
-	errorList := make([]error, 0, 10)

 	for org, configs := range s.processor.configuredRepos {
 		for _, config := range configs {
@@ -175,12 +182,12 @@ func (s *DefaultStateChecker) CheckRepos() error {
 			prs, err := s.i.VerifyProjectState(config)
 			if err != nil {
 				common.LogError(" *** verification failed, org:", org, err)
-				errorList = append(errorList, err)
 			}
 			for _, pr := range prs {
 				prs, err := Gitea.GetRecentPullRequests(pr.Org, pr.Repo, pr.Branch)
 				if err != nil {
-					return fmt.Errorf("Error fetching pull requests for %s/%s#%s. Err: %w", pr.Org, pr.Repo, pr.Branch, err)
+					common.LogError("Error fetching pull requests for", fmt.Sprintf("%s/%s#%s", pr.Org, pr.Repo, pr.Branch), err)
+					break
 				}
 				if len(prs) > 0 {
 					common.LogDebug(fmt.Sprintf("%s/%s#%s", pr.Org, pr.Repo, pr.Branch), "  - # of PRs to check:", len(prs))
@@ -193,9 +200,11 @@ func (s *DefaultStateChecker) CheckRepos() error {

 			common.LogInfo(" ++ verification complete, org:", org, "config:", config.GitProjectName)
 		}
-	}

-	return errors.Join(errorList...)
+		if len(configs) == 0 {
+			common.LogError("   org:", org, "has 0 configs?")
+		}
+	}
 }

 func (s *DefaultStateChecker) ConsistencyCheckProcess() error {
Author	SHA256	Message	Date
Adam Majer	cc675c1b24	devel: ignore dot files magic hash is when no files exist and echo "" is passed to md5sum	2025-11-20 19:57:35 +01:00
Adam Majer	44e4941120	devel: handle build.specials.obscpio	2025-11-20 19:40:49 +01:00
Adam Majer	86acfa6871	pr: set staging auto label according to config falls back to staging/Auto if nothing is set	2025-11-20 16:25:06 +01:00
Adam Majer	7f09b2d2d3	common: match project config before packages We need to cycle through all project configs before we try to match non-project config branches/packages. If we have multiple project gits in one org, this coudl match wrong config	2025-11-20 13:22:40 +01:00
Adam Majer	f3a37f1158	pr: case fold	2025-11-19 19:32:55 +01:00
Adam Majer	9d6db86318	pr: log case of no config in verification check	2025-11-19 17:10:08 +01:00
Adam Majer	e11993c81f	pr: do not stop processing if failed on some pacakge during check	2025-11-19 16:36:48 +01:00
Adam Majer	4bd259a2a0	pr: ignore pkg PR if not open and no PrjGit PR	2025-11-19 16:35:17 +01:00
Adam Majer	162ae11cdd	common: init the cache so not null	2025-11-19 15:29:52 +01:00
Adam Majer	8431b47322	group-review: allow dots in org and package names	2025-11-19 10:00:39 +01:00
Adam Majer	3ed5ecc3f0	pr: add staging/Auto on new PRs also, cache timeline fetches	2025-11-17 11:01:45 +01:00
Adam Majer	d08ab3efd6	direct: support reverts	2025-11-13 23:52:05 +01:00
Adam Majer	a4f6628e52	direct: always deinit, even if dirty	2025-11-13 23:51:18 +01:00
Adam Majer	25073dd619	direct: use correct remote name for submodules should be "origin"	2025-11-13 22:15:00 +01:00
Adam Majer	4293181b4e	pr: improve logging of review errors when user is missing, log only the missing user	2025-11-12 21:39:26 +01:00
Adam Majer	551a4ef577	direct: use origin for submodule checkout	2025-11-10 11:03:54 +01:00
Adam Majer	6afb18fc58	direct: use correct repo for default branch	2025-11-10 10:24:33 +01:00
Adam Majer	f310220261	direct: log default branch	2025-11-10 10:11:11 +01:00
Adam Majer	ef7c0c1cea	direct: fix debug logging	2025-11-10 09:42:43 +01:00
Adam Majer	27230fa03b	direct: fix debug logging	2025-11-10 09:34:10 +01:00
Adam Majer	c52d40b760	direct: explicit path for config bind	2025-11-09 23:26:04 +01:00
Adam Majer	d3ba579a8b	common: fix systemd execution In case when we are running under older systemd that does not set transient home, we need to improvise when connecting via SSH and passing the identity file explicitly	2025-11-09 23:10:08 +01:00
Adam Majer	9ef8209622	direct: bind config to working directory Use temp /run instance directory for the config Use ./config.json as default from within the process	2025-11-07 17:06:27 +01:00
Adam Majer	ba66dd868e	direct: fix running bot without any config params Only use env variables.	2025-11-07 16:19:13 +01:00
Adam Majer	17755fa2b5	status: fix repo links for monitor page	2025-11-07 13:59:52 +01:00
Adam Majer	f94d3a8942	status: update README	2025-11-05 16:56:30 +01:00
Adam Majer	20e1109602	spec: packaging fixes * Update Version to 1, since we now have devel project and updates should have version bump instead of downgrade * other fixes	2025-11-05 16:38:15 +01:00
Adam Majer	c25d3be44e	direct: add systemd unit file	2025-11-05 13:24:54 +01:00
Adam Majer	8db558891a	direct: remove config.Branch clobbering use our own copy of branch instead of writing it in the config. This should fix handling of default branches where the default branch differs between repositories.	2025-11-04 18:00:21 +01:00
Adam Majer	0e06ba5993	common: classifying rm branches on name Branches with suffixes -rm -removed -deleted are now classified as removed. This is important in case project config refers to default branch names which must exist so we need to be able to classify such branches to either use them or ignore them	2025-11-04 18:00:21 +01:00
Adam Majer	736769d630	direct: add a repo with branch but no submodule	2025-11-04 18:00:21 +01:00
Adam Majer	93c970d0dd	direct: move logging to common.Log* function	2025-11-04 18:00:21 +01:00
Adrian Schröter	5544a65947	obs-staging-bot: Expand possible branch of QA repos That way a source merge of any product is not triggering rebuilds in pull request QA sub projects. We may need a config option here to enable/disable this.	2025-11-03 17:54:57 +01:00
Adam Majer	918723d57b	Merge commit '55846562c1d9dcb395e545f7c8e0bcb74c47b85693f4e955ef488530781b9bf2' PR!88	2025-11-03 17:49:45 +01:00
Adam Majer	a418b48809	pr: process PR on comments, not issue changes	2025-10-31 13:07:18 +01:00
Santiago Zarate	55846562c1	Add simple readme for gitea_status_proxy	2025-10-31 10:33:58 +01:00
Santiago Zarate	95c7770cad	Change log level for auth errors	2025-10-31 10:33:58 +01:00
Santiago Zarate	1b900e3202	Properly proxy json input directly to gitea	2025-10-31 10:33:51 +01:00
Santiago Zarate	d083acfd1c	Be more verbose about authentication errors	2025-10-30 13:09:17 +01:00
Santiago Zarate	244160e20e	Update authorization headers For gitea API AuthorizationHeaderToken tokens must be prepended with "token" followed by a space, also fix content type	2025-10-30 13:09:17 +01:00