WIP: conflict resolution

.gitignore

@@ -1,3 +1,4 @@
+mock
 node_modules
 *.obscpio
 autogits-tmp.tar.zst

autogits.spec

@@ -23,7 +23,6 @@ Summary:        GitWorkflow utilities
 License:        GPL-2.0-or-later
 URL:            https://src.opensuse.org/adamm/autogits
 Source1:        vendor.tar.zst
-BuildRequires:  git
 BuildRequires:  golang-packaging
 BuildRequires:  systemd-rpm-macros
 BuildRequires:  zstd
@@ -34,22 +33,6 @@ Git Workflow tooling and utilities enabling automated handing of OBS projects
 as git repositories
 
 
-
-
-%package -n devel-importer
-Summary:        Imports devel projects from obs to git
-
-%description -n devel-importer
-Command-line tool to import devel projects from obs to git
-
-
-%package -n doc
-Summary:        Common documentation files
-
-%description -n doc
-Common documentation files
-
-
 %package -n gitea-events-rabbitmq-publisher
 Summary:        Publishes Gitea webhook data via RabbitMQ
 
@@ -59,10 +42,18 @@ with a topic
   <scope>.src.$organization.$webhook_type.[$webhook_action_type]
 
 
-%package -n gitea-status-proxy
-Summary:        gitea-status-proxy
+%package -n doc
+Summary:        Common documentation files
 
-%description -n gitea-status-proxy
+%description -n doc
+Common documentation files
+
+
+%package -n devel-importer
+Summary:        Imports devel projects from obs to git
+
+%description -n devel-importer
+Command-line tool to import devel projects from obs to git
 
 
 %package -n group-review
@@ -73,12 +64,6 @@ Is used to handle reviews associated with groups defined in the
 ProjectGit.
 
 
-%package -n obs-forward-bot
-Summary:        obs-forward-bot
-
-%description -n obs-forward-bot
-
-
 %package -n obs-staging-bot
 Summary:        Build a PR against a ProjectGit, if review is requested
 
@@ -113,26 +98,18 @@ cp -r /home/abuild/rpmbuild/SOURCES/* ./
 tar x --zstd -f %{SOURCE1}
 
 %build
-go build \
-   -C devel-importer \
-   -mod=vendor \
-   -buildmode=pie
 go build \
    -C gitea-events-rabbitmq-publisher \
    -mod=vendor \
    -buildmode=pie
 go build \
-   -C gitea_status_proxy \
+   -C devel-importer \
    -mod=vendor \
    -buildmode=pie
 go build \
    -C group-review \
    -mod=vendor \
    -buildmode=pie
-go build \
-   -C obs-forward-bot \
-   -mod=vendor \
-   -buildmode=pie
 go build \
    -C obs-staging-bot \
    -mod=vendor \
@@ -141,36 +118,24 @@ go build \
    -C obs-status-service \
    -mod=vendor \
    -buildmode=pie
-go build \
-   -C workflow-direct \
-   -mod=vendor \
-   -buildmode=pie
-go build \
-   -C workflow-pr \
-   -mod=vendor \
-   -buildmode=pie
-
-%check
-# TODO currently needs the source git history, maybe rewrite to create a git repo in the test?
-#go test -C common
-go test -C group-review
-go test -C obs-staging-bot
-go test -C obs-status-service
-go test -C workflow-direct
-# TODO build fails
-go test -C workflow-pr
+#go build \
+#   -C workflow-direct \
+#   -mod=vendor \
+#   -buildmode=pie
+#go build \
+#   -C workflow-pr \
+#   -mod=vendor \
+#   -buildmode=pie
 
 %install
-install -D -m0755 devel-importer/devel-importer                                    %{buildroot}%{_bindir}/devel-importer
 install -D -m0755 gitea-events-rabbitmq-publisher/gitea-events-rabbitmq-publisher  %{buildroot}%{_bindir}/gitea-events-rabbitmq-publisher
 install -D -m0644 systemd/gitea-events-rabbitmq-publisher.service                  %{buildroot}%{_unitdir}/gitea-events-rabbitmq-publisher.service
-install -D -m0755 gitea_status_proxy/gitea_status_proxy                            %{buildroot}%{_bindir}/gitea_status_proxy
+install -D -m0755 devel-importer/devel-importer                                    %{buildroot}%{_bindir}/devel-importer
 install -D -m0755 group-review/group-review                                        %{buildroot}%{_bindir}/group-review
-install -D -m0755 obs-forward-bot/obs-forward-bot                                  %{buildroot}%{_bindir}/obs-forward-bot
 install -D -m0755 obs-staging-bot/obs-staging-bot                                  %{buildroot}%{_bindir}/obs-staging-bot
 install -D -m0755 obs-status-service/obs-status-service                            %{buildroot}%{_bindir}/obs-status-service
-install -D -m0755 workflow-direct/workflow-direct                                  %{buildroot}%{_bindir}/workflow-direct
-install -D -m0755 workflow-pr/workflow-pr                                          %{buildroot}%{_bindir}/workflow-pr
+#install -D -m0755 workflow-direct/workflow-direct                                  %{buildroot}%{_bindir}/workflow-direct
+#install -D -m0755 workflow-pr/workflow-pr                                          %{buildroot}%{_bindir}/workflow-pr
 
 %pre -n gitea-events-rabbitmq-publisher
 %service_add_pre gitea-events-rabbitmq-publisher.service
@@ -184,35 +149,27 @@ install -D -m0755 workflow-pr/workflow-pr
 %postun -n gitea-events-rabbitmq-publisher
 %service_del_postun gitea-events-rabbitmq-publisher.service
 
-%files -n devel-importer
-%license COPYING
-%doc devel-importer/README.md
-%{_bindir}/devel-importer
-
-%files -n doc
-%license COPYING
-%doc doc/README.md
-%doc doc/workflows.md
-
 %files -n gitea-events-rabbitmq-publisher
 %license COPYING
 %doc gitea-events-rabbitmq-publisher/README.md
 %{_bindir}/gitea-events-rabbitmq-publisher
 %{_unitdir}/gitea-events-rabbitmq-publisher.service
 
-%files -n gitea-status-proxy
+%files -n doc
 %license COPYING
-%{_bindir}/gitea_status_proxy
+%doc doc/README.md
+%doc doc/workflows.md
+
+%files -n devel-importer
+%license COPYING
+%doc devel-importer/README.md
+%{_bindir}/devel-importer
 
 %files -n group-review
 %license COPYING
 %doc group-review/README.md
 %{_bindir}/group-review
 
-%files -n obs-forward-bot
-%license COPYING
-%{_bindir}/obs-forward-bot
-
 %files -n obs-staging-bot
 %license COPYING
 %doc obs-staging-bot/README.md
@@ -226,10 +183,10 @@ install -D -m0755 workflow-pr/workflow-pr
 %files -n workflow-direct
 %license COPYING
 %doc workflow-direct/README.md
-%{_bindir}/workflow-direct
+#%{_bindir}/workflow-direct
 
 %files -n workflow-pr
 %license COPYING
 %doc workflow-pr/README.md
-%{_bindir}/workflow-pr
+#%{_bindir}/workflow-pr
 

common/config.go

@@ -43,7 +43,6 @@ type ConfigFile struct {
 
 type ReviewGroup struct {
 	Name      string
-	Silent    bool // will not request reviews from group members
 	Reviewers []string
 }
 
@@ -58,9 +57,8 @@ type AutogitConfig struct {
 	GitProjectName string   // Organization/GitProjectName.git is PrjGit
 	Branch         string   // branch name of PkgGit that aligns with PrjGit submodules
 	Reviewers      []string // only used by `pr` workflow
-	ReviewGroups   []*ReviewGroup
+	ReviewGroups   []ReviewGroup
 	Committers     []string // group in addition to Reviewers and Maintainers that can order the bot around, mostly as helper for factory-maintainers
-	Subdirs        []string // list of directories to sort submodules into. Needed b/c _manifest cannot list non-existent directories
 
 	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
@@ -195,19 +193,10 @@ func (config *AutogitConfig) GetReviewGroupMembers(reviewer string) ([]string, e
 	return nil, errors.New("User " + reviewer + " not found as group reviewer for " + config.GitProjectName)
 }
 
-func (config *AutogitConfig) GetReviewGroup(reviewer string) (*ReviewGroup, error) {
-	for _, g := range config.ReviewGroups {
-		if g.Name == reviewer {
-			return g, nil
-		}
-	}
-	return nil, errors.New("User " + reviewer + " not found as group reviewer for " + config.GitProjectName)
-}
-
 func (config *AutogitConfig) GetPrjGit() (string, string, string) {
 	org := config.Organization
 	repo := DefaultGitPrj
-	branch := ""
+	branch := "master"
 
 	a := strings.Split(config.GitProjectName, "/")
 	if len(a[0]) > 0 {
@@ -231,9 +220,6 @@ func (config *AutogitConfig) GetPrjGit() (string, string, string) {
 		}
 	}
 
-	if len(branch) == 0 {
-		panic("branch for project is undefined. Should not happend." + org + "/" + repo)
-	}
 	return org, repo, branch
 }
 

common/git_utils.go

@@ -274,17 +274,12 @@ func (e *GitHandlerImpl) GitClone(repo, branch, remoteUrl string) (string, error
 }
 
 func (e *GitHandlerImpl) GitBranchHead(gitDir, branchName string) (string, error) {
-	id, err := e.GitExecWithOutput(gitDir, "show-ref", "--branch", "--hash", branchName)
+	id, err := e.GitExecWithOutput(gitDir, "show-ref", "--hash", "--verify", "refs/heads/"+branchName)
 	if err != nil {
 		return "", fmt.Errorf("Can't find default branch: %s", branchName)
 	}
 
-	id = strings.TrimSpace(SplitLines(id)[0])
-	if len(id) < 10 {
-		return "", fmt.Errorf("Can't find branch: %s", branchName)
-	}
-
-	return id, nil
+	return strings.TrimSpace(id), nil
 }
 
 func (e *GitHandlerImpl) GitRemoteHead(gitDir, remote, branchName string) (string, error) {
@@ -350,7 +345,6 @@ func (e *GitHandlerImpl) GitExecWithOutput(cwd string, params ...string) (string
 		"GIT_COMMITTER_NAME=" + e.GitCommiter,
 		"EMAIL=not@exist@src.opensuse.org",
 		"GIT_LFS_SKIP_SMUDGE=1",
-		"GIT_LFS_SKIP_PUSH=1",
 		"GIT_SSH_COMMAND=/usr/bin/ssh -o StrictHostKeyChecking=yes",
 	}
 	if len(ExtraGitParams) > 0 {

common/gitea_utils.go

@@ -160,10 +160,6 @@ type GiteaCommitStatusGetter interface {
 	GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error)
 }
 
-type GiteaMerger interface {
-	ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error
-}
-
 type Gitea interface {
 	GiteaComment
 	GiteaRepoFetcher
@@ -172,7 +168,6 @@ type Gitea interface {
 	GiteaReviewer
 	GiteaPRFetcher
 	GiteaPRUpdater
-	GiteaMerger
 	GiteaCommitFetcher
 	GiteaReviewFetcher
 	GiteaCommentFetcher
@@ -238,11 +233,6 @@ func (gitea *GiteaTransport) GetPullRequest(org, project string, num int64) (*mo
 		gitea.transport.DefaultAuthentication,
 	)
 
-	if err != nil {
-		LogError(err)
-		return nil, err
-	}
-
 	return pr.Payload, err
 }
 
@@ -256,36 +246,9 @@ func (gitea *GiteaTransport) UpdatePullRequest(org, repo string, num int64, opti
 		gitea.transport.DefaultAuthentication,
 	)
 
-	if err != nil {
-		LogError(err)
-		return nil, err
-	}
-
 	return pr.Payload, err
 }
 
-func (gitea *GiteaTransport) ManualMergePR(org, repo string, num int64, commitid string, delBranch bool) error {
-	manual_merge := "manually-merged"
-	_, err := gitea.client.Repository.RepoMergePullRequest(
-		repository.NewRepoMergePullRequestParams().
-			WithOwner(org).
-			WithRepo(repo).
-			WithIndex(num).
-			WithBody(&models.MergePullRequestForm{
-				Do:                     &manual_merge,
-				DeleteBranchAfterMerge: delBranch,
-				HeadCommitID:           commitid,
-			}), gitea.transport.DefaultAuthentication,
-	)
-
-	if err != nil {
-		LogError(err)
-		return err
-	}
-
-	return nil
-}
-
 func (gitea *GiteaTransport) GetPullRequests(org, repo string) ([]*models.PullRequest, error) {
 	var page, limit int64
 
@@ -647,11 +610,7 @@ func (gitea *GiteaTransport) CreatePullRequestIfNotExist(repo *models.Repository
 	}
 
 	if pr, err := gitea.client.Repository.RepoGetPullRequestByBaseHead(
-		repository.NewRepoGetPullRequestByBaseHeadParams().
-			WithOwner(repo.Owner.UserName).
-			WithRepo(repo.Name).
-			WithBase(targetId).
-			WithHead(srcId),
+		repository.NewRepoGetPullRequestByBaseHeadParams().WithOwner(repo.Owner.UserName).WithRepo(repo.Name).WithBase(targetId).WithHead(srcId),
 		gitea.transport.DefaultAuthentication,
 	); err == nil {
 		return pr.Payload, nil

common/listen.go

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

common/listen_test.go

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

common/manifest.go

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

common/manifest_test.go

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

common/mock/config.go

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

common/mock/maintainership.go

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

common/mock/obs_utils.go

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

common/obs_utils.go

@@ -562,57 +562,25 @@ func (c *ObsClient) DeleteProject(project string) error {
 	}
 
 	return nil
-}
 
-func (c *ObsClient) BuildLog(prj, pkg, repo, arch string) (io.ReadCloser, error) {
-	url := c.baseUrl.JoinPath("build", prj, repo, arch, pkg, "_log")
-	query := url.Query()
-	query.Add("nostream", "1")
-	query.Add("start", "0")
-	url.RawQuery = query.Encode()
-	res, err := c.ObsRequestRaw("GET", url.String(), nil)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return res.Body, nil
 }
 
 type PackageBuildStatus struct {
 	Package string `xml:"package,attr"`
 	Code    string `xml:"code,attr"`
 	Details string `xml:"details"`
-
-	LastUpdate time.Time
-}
-
-func PackageBuildStatusComp(A, B *PackageBuildStatus) int {
-	return strings.Compare(A.Package, B.Package)
 }
 
 type BuildResult struct {
-	Project    string                `xml:"project,attr"`
-	Repository string                `xml:"repository,attr"`
-	Arch       string                `xml:"arch,attr"`
-	Code       string                `xml:"code,attr"`
-	Dirty      bool                  `xml:"dirty,attr"`
-	ScmSync    string                `xml:"scmsync"`
-	ScmInfo    string                `xml:"scminfo"`
-	Status     []*PackageBuildStatus `xml:"status"`
-	Binaries   []BinaryList          `xml:"binarylist"`
-
-	LastUpdate time.Time
-}
-
-func BuildResultComp(A, B *BuildResult) int {
-	if cmp := strings.Compare(A.Project, B.Project); cmp != 0 {
-		return cmp
-	}
-	if cmp := strings.Compare(A.Repository, B.Repository); cmp != 0 {
-		return cmp
-	}
-	return strings.Compare(A.Arch, B.Arch)
+	Project    string               `xml:"project,attr"`
+	Repository string               `xml:"repository,attr"`
+	Arch       string               `xml:"arch,attr"`
+	Code       string               `xml:"code,attr"`
+	Dirty      bool                 `xml:"dirty,attr"`
+	ScmSync    string               `xml:"scmsync"`
+	ScmInfo    string               `xml:"scminfo"`
+	Status     []PackageBuildStatus `xml:"status"`
+	Binaries   []BinaryList         `xml:"binarylist"`
 }
 
 type Binary struct {
@@ -629,7 +597,7 @@ type BinaryList struct {
 type BuildResultList struct {
 	XMLName xml.Name      `xml:"resultlist"`
 	State   string        `xml:"state,attr"`
-	Result  []*BuildResult `xml:"result"`
+	Result  []BuildResult `xml:"result"`
 
 	isLastBuild bool
 }

common/pr.go

@@ -25,13 +25,6 @@ type PRSet struct {
 	BotUser string
 }
 
-func (prinfo *PRInfo) PRComponents() (org string, repo string, idx int64) {
-	org = prinfo.PR.Base.Repo.Owner.UserName
-	repo = prinfo.PR.Base.Repo.Name
-	idx = prinfo.PR.Index
-	return
-}
-
 func readPRData(gitea GiteaPRFetcher, pr *models.PullRequest, currentSet []*PRInfo, config *AutogitConfig) ([]*PRInfo, error) {
 	for _, p := range currentSet {
 		if pr.Index == p.PR.Index && pr.Base.Repo.Name == p.PR.Base.Repo.Name && pr.Base.Repo.Owner.UserName == p.PR.Base.Repo.Owner.UserName {

common/pr_conflict_resolution.go

@@ -0,0 +1,48 @@
+package common
+
+import (
+	"errors"
+	"strings"
+)
+
+var UnknownParser error = errors.New("Cannot parse path")
+
+type PRConflictResolver interface {
+	/*
+		stage_content -> { merge_base (stage1), head (stage2), merge_head (stage3) }
+	*/
+	Resolve(path string, stage_contents [3]string) error
+}
+
+var resolvers []PRConflictResolver = []PRConflictResolver{
+	&submodule_conflict_resolver{},
+}
+
+func ResolveMergeConflict(path string, file_contents [3]string) error {
+	for _, r := range resolvers {
+		if err := r.Resolve(path, file_contents); err != UnknownParser {
+			return err
+		}
+	}
+
+	return UnknownParser
+}
+
+type submodule_conflict_resolver struct{}
+
+func (*submodule_conflict_resolver) Resolve(path string, stage [3]string) error {
+	if path != ".gitmodules" {
+		return UnknownParser
+	}
+	return UnknownParser
+}
+
+type changes_file_resolver struct{}
+
+func (*changes_file_resolver) Resolve(path string, stage [3]string) error {
+	if !strings.HasSuffix(path, ".changes") {
+		return UnknownParser
+	}
+
+	return UnknownParser
+}

common/pr_conflict_resolution_test.go

@@ -0,0 +1,10 @@
+package common_test
+
+import "testing"
+
+func ResolveSubmoduleConflicts(t *testing.T) {
+}
+
+func ResolveChangesFileConflict(t *testing.T) {
+}
+

common/rabbitmq.go

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

common/rabbitmq_gitea.go

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

common/rabbitmq_obs.go

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

common/submodules.go

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

containers/Makefile

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

containers/workflow-direct/.gitignore

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

containers/workflow-direct/Containerfile

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

containers/workflow-direct/known_hosts

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

containers/workflow-pr/.gitignore

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

containers/workflow-pr/Containerfile

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

containers/workflow-pr/known_hosts

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

devel-importer/main.go

@@ -23,6 +23,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"io/fs"
 	"log"
 	"net/url"
 	"os"
@@ -72,10 +73,6 @@ func runObsCommand(args ...string) ([]string, error) {
 
 var DebugMode bool
 
-func giteaPackage(pkg string) string {
-	return strings.ReplaceAll(pkg, "+", "_")
-}
-
 func projectMaintainer(obs *common.ObsClient, prj string) ([]string, []string) { // users, groups
 	meta, err := obs.GetProjectMeta(prj)
 	if err != nil {
@@ -146,9 +143,7 @@ func listMaintainers(obs *common.ObsClient, prj string, pkgs []string) {
 			log.Panicln(err)
 		}
 
-		if user != nil {
-			contact_email = append(contact_email, fmt.Sprintf("%s <%s>", user.Name, user.Email))
-		}
+		contact_email = append(contact_email, fmt.Sprintf("%s <%s>", user.Name, user.Email))
 	}
 	log.Println(strings.Join(contact_email, ", "))
 }
@@ -159,7 +154,6 @@ func gitImporter(prj, pkg string) error {
 		params = append(params, "-l", "debug")
 	}
 	params = append(params, pkg)
-	common.LogDebug("git-importer", params)
 	cmd := exec.Command("./git-importer", params...)
 	if idx := slices.IndexFunc(cmd.Env, func(val string) bool { return val[0:12] == "GITEA_TOKEN=" }); idx != -1 {
 		cmd.Env = slices.Delete(cmd.Env, idx, idx+1)
@@ -172,113 +166,317 @@ func gitImporter(prj, pkg string) error {
 	return nil
 }
 
-func cloneDevel(git common.Git, gitDir, outName, urlString, remote string, fatal bool) error {
-	if url, _ := url.Parse(urlString); url != nil {
-		url.Fragment = ""
-		urlString = url.String()
-	}
+func cloneDevel(git common.Git, gitDir, outName, urlString string) error {
+	url, err := url.Parse(urlString)
+	// branch := url.Fragment
+	url.Fragment = ""
 
-	params := []string{"clone", "-o", remote}
-	params = append(params, urlString, outName)
+	params := []string{"clone"}
+	/*	if len(branch) > 0 {
+			params = append(params, "-b", branch)
+		}
+	*/
+	params = append(params, url.String(), outName)
 
-	if fatal {
-		git.GitExecOrPanic(gitDir, params...)
-	} else {
-		git.GitExec(gitDir, params...)
+	if err != nil {
+		return fmt.Errorf("error parsing SSH URL. %w", err)
 	}
+	git.GitExecOrPanic(gitDir, params...)
 	return nil
 }
 
-func findMissingDevelBranch(git common.Git, pkg, project string) {
-	d, err := git.GitBranchHead(pkg, "devel")
-	if err != nil {
-		if _, err = git.GitBranchHead(pkg, "factory"); err != nil {
-			log.Println("factory is missing... so maybe repo is b0rked.")
-			return
-		}
+func importRepos(packages []string) {
+	factoryRepos := make([]*models.Repository, 0, len(packages)*2)
+	develProjectPackages := make([]string, 0, len(packages))
+	for _, pkg := range packages {
+		src_pkg_name := strings.Split(pkg, ":")
+		repo, err := client.Repository.RepoGet(
+			repository.NewRepoGetParams().
+				WithDefaults().WithOwner("pool").WithRepo(src_pkg_name[0]),
+			r.DefaultAuthentication)
 
-		hash := common.SplitLines(git.GitExecWithOutputOrPanic(pkg,
-			"log",
-			"factory",
-			"--all",
-			"--grep=build.opensuse.org/package/show/"+project+"/"+pkg,
-			"-1",
-			"--pretty=format:%H"))
-		if len(hash) > 0 {
-			log.Println("  devel @", hash[0])
-			git.GitExecOrPanic(pkg, "branch", "devel", hash[0])
+		if err != nil {
+			if !errors.Is(err, &repository.RepoGetNotFound{}) {
+				log.Panicln(err)
+			}
+
+			log.Println("Cannot find src package:", src_pkg_name)
+			develProjectPackages = append(develProjectPackages, src_pkg_name[0])
 		} else {
-			git.GitExecOrPanic(pkg, "branch", "devel", "factory")
+			factoryRepos = append(factoryRepos, repo.Payload)
+		}
+	}
+	log.Println("Num repos found:", len(factoryRepos))
+	if len(develProjectPackages) > 0 {
+		log.Println("Num of repos that need to create:", len(develProjectPackages))
+		log.Println("Create the following packages in pool to continue:", strings.Join(develProjectPackages, " "))
+		if forceNonPoolPackages {
+			log.Println(" IGNORING and will create these as non-pool packages!")
+		} else {
+			os.Exit(1)
 		}
-	} else {
-		log.Println("  devel already exists?", d)
 	}
-}
 
-func importFactoryRepoAndCheckHistory(pkg string, meta *common.PackageMeta) (factoryRepo *models.Repository, retErr error) {
-	if repo, err := client.Repository.RepoGet(repository.NewRepoGetParams().WithDefaults().WithOwner("pool").WithRepo(giteaPackage(pkg)), r.DefaultAuthentication); err != nil || repo.Payload.ObjectFormatName != "sha256" {
-		if err != nil && !errors.Is(err, &repository.RepoGetNotFound{}) {
+	oldPackageNames := make([]string, 0, len(factoryRepos))
+	for _, repo := range factoryRepos {
+		oldPackageNames = append(oldPackageNames, repo.Name)
+	}
+
+	// fork packags from pool
+	for i := 0; i < len(oldPackageNames); {
+		pkg := oldPackageNames[i]
+		log.Println(" + package:", pkg)
+		if err := gitImporter("openSUSE:Factory", pkg); err != nil {
+			log.Println(" ** failed to import openSUSE:Factory", pkg)
+			log.Println(" ** falling back to devel project only")
+
+			develProjectPackages = append(develProjectPackages, pkg)
+			oldPackageNames = slices.Delete(oldPackageNames, i, i+1)
+		} else {
+			i++
+		}
+
+	}
+
+	log.Println("adding remotes...")
+	for i := 0; i < len(factoryRepos); i++ {
+		pkg := factoryRepos[i]
+
+		// verify that package was created by `git-importer`, or it's scmsync package and clone it
+		fi, err := os.Stat(filepath.Join(git.GetPath(), pkg.Name))
+		if os.IsNotExist(err) {
+			if slices.Contains(develProjectPackages, pkg.Name) {
+				// failed import of former factory package
+				continue
+			}
+
+			// scmsync?
+			devel_project, err := devel_projects.GetDevelProject(pkg.Name)
+			if err != nil {
+				log.Panicln("devel project not found for", pkg.Name, "err:", err)
+			}
+			meta, _ := obs.GetPackageMeta(devel_project, pkg.Name)
+			if len(meta.ScmSync) > 0 {
+				if err2 := cloneDevel(git, "", pkg.Name, meta.ScmSync); err != nil {
+					log.Panicln(err2)
+				}
+				git.GitExecOrPanic(pkg.Name, "checkout", "-B", "main")
+				continue
+			}
+
+			// try again, should now exist
+			if fi, err = os.Stat(filepath.Join(git.GetPath(), pkg.Name)); err != nil {
+				log.Panicln(err)
+			}
+		} else if err != nil {
 			log.Panicln(err)
+		} else {
+			// verify that we do not have scmsync for imported packages
+			meta, err := obs.GetPackageMeta(prj, pkg.Name)
+			if err != nil {
+				log.Panicln(err)
+			}
+
+			if len(meta.ScmSync) > 0 {
+				log.Panicln("importing an scmsync package??:", prj, pkg.Name)
+			}
 		}
 
-		log.Println("Cannot find src package:", pkg)
-		return nil, nil
-	} else {
-		factoryRepo = repo.Payload
-		CreatePoolFork(factoryRepo)
-	}
+		if !fi.IsDir() {
+			log.Panicln("Expected package file should be a directory. It's not.", fi)
+		}
 
-	if _, err := os.Stat(filepath.Join(git.GetPath(), pkg)); os.IsNotExist(err) {
-		common.LogDebug("Cloning factory...")
-		cloneDevel(git, "", pkg, factoryRepo.CloneURL, "pool", true) // in case we have imported
-	} else if err != nil {
-		common.PanicOnError(err)
-	} else {
-		// we have already cloned it... so, fetch pool remote
-		common.LogDebug("Fetching pool, as already should have the remote")
-		if err = git.GitExec(pkg, "fetch", "pool"); err != nil {
-			common.LogError(err)
-			return factoryRepo, err
+		// add remote repos
+		out := git.GitExecWithOutputOrPanic(pkg.Name, "remote", "show", "-n")
+		switch pkg.Owner.UserName {
+		case "pool":
+			if !slices.Contains(strings.Split(out, "\n"), "pool") {
+				out := git.GitExecWithOutputOrPanic(pkg.Name, "remote", "add", "pool", pkg.CloneURL)
+				if len(strings.TrimSpace(out)) > 1 {
+					log.Println(out)
+				}
+			}
+		default:
+			log.Panicln(pkg.Owner.UserName)
 		}
 	}
 
-	roots := 0
-	if _, err := git.GitRemoteHead(pkg, "pool", "devel"); err == nil {
-		factory_roots := strings.TrimSpace(git.GitExecWithOutputOrPanic(pkg, "rev-list", "pool/factory", "--max-parents=0"))
-		devel_roots := strings.TrimSpace(git.GitExecWithOutputOrPanic(pkg, "rev-list", "pool/devel", "--max-parents=0"))
-		roots = len(common.SplitLines(factory_roots))
-		if devel_roots != factory_roots || len(common.SplitLines(factory_roots)) != 1 {
-			roots = 10
+	for _, pkgName := range oldPackageNames {
+		log.Println("fetching git:", pkgName)
+		remotes := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgName, "remote", "show", "-n"), "\n")
+
+		params := []string{"fetch", "--multiple"}
+		params = append(params, remotes...)
+		out, _ := git.GitExecWithOutput(pkgName, params...)
+		if len(strings.TrimSpace(out)) > 1 {
+			log.Println(out)
+		}
+
+		if slices.Contains(remotes, "origin") {
+			log.Println("  --- scmsync already, so we are done")
+			continue
+		}
+
+		// check if devel is ahead or behind factory and use that as reference
+		import_branch := "factory"
+		if len(common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgName, "rev-list", "^factory", "devel"), "\n")) > 0 {
+			log.Println(" *** devel ahead. Swtiching branches.")
+			import_branch = "devel"
+		}
+
+		// check that nothing is broken with the update
+		if slices.Contains(remotes, "pool") {
+			// check which branch is ahead
+			branches, err := fs.ReadDir(os.DirFS(path.Join(git.GetPath(), pkgName, ".git/refs/remotes")), "pool")
+			if err != nil {
+				if forceBadPool {
+					log.Println(" *** factory has no branches!!! Treating as a devel package.")
+					develProjectPackages = append(develProjectPackages, pkgName)
+					break
+				} else {
+					log.Panicln(" *** factory has no branches", branches)
+				}
+			}
+			pool_branch := "factory"
+
+			has_factory_devel := false
+			has_factory_factory := false
+
+			for _, branch := range branches {
+				if branch.Name() == "factory" {
+					has_factory_factory = true
+				} else if branch.Name() == "devel" {
+					has_factory_devel = true
+				}
+			}
+			log.Println(branches)
+
+			if has_factory_devel && has_factory_factory {
+				if len(common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgName, "rev-list", "^pool/factory", "pool/devel"), "\n")) > 0 {
+					log.Println(" *** pool branch devel ahead. Switching branches.")
+					pool_branch = "devel"
+				}
+			} else if has_factory_devel && !has_factory_factory {
+				pool_branch = "devel"
+			} else if !has_factory_devel && has_factory_factory {
+
+			} else {
+				log.Panicln("branches screwed up for pkg", pkgName, branches)
+			}
+
+			// find tree object in factory branch
+			tree := strings.TrimSpace(git.GitExecWithOutputOrPanic(pkgName, "rev-list", "-1", "--format=%T", "--no-commit-header", "pool/"+pool_branch))
+			log.Println("tree", tree)
+			import_tree_commits := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgName, "rev-list", "--format=%H %T", "--no-commit-header", import_branch), "\n")
+			found := false
+			for i := range import_tree_commits {
+				commit_tree := strings.Split(import_tree_commits[i], " ")
+				if len(commit_tree) != 2 {
+					log.Panicln("wrong format?", commit_tree)
+				}
+				if commit_tree[1] == tree {
+					found = true
+					cherry_picks := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkgName, "rev-list", "--no-merges", "--reverse", "--ancestry-path", commit_tree[0]+".."+import_branch), "\n")
+
+					log.Println("cherry picks", cherry_picks)
+					git.GitExecOrPanic(pkgName, "checkout", "-B", "main", "pool/"+pool_branch)
+					for _, pick := range cherry_picks {
+						git.GitExecOrPanic(pkgName, "cherry-pick", pick)
+					}
+					break
+				}
+			}
+
+			if !found {
+				log.Println("*** WARNING: Cannot find same tree for pkg", pkgName, "Will use current import instead")
+				git.GitExecOrPanic(pkgName, "checkout", "-B", "main", "heads/"+import_branch)
+			}
+		} else {
+			git.GitExecOrPanic(pkgName, "checkout", "-B", "main", "heads/"+import_branch)
 		}
-	} else if _, err := git.GitRemoteHead(pkg, "pool", "factory"); err == nil {
-		items := strings.TrimSpace(git.GitExecWithOutputOrPanic(pkg, "rev-list", "pool/factory", "--max-parents=0"))
-		roots = len(common.SplitLines(items))
-	} else {
-		common.LogInfo("No factory import ...")
 	}
 
-	if roots != 1 {
-		common.LogError("Expected 1 root in factory, but found", roots)
-		common.LogError("Ignoring current import")
-		common.PanicOnError(os.RemoveAll(path.Join(git.GetPath(), pkg)))
-		retErr = fmt.Errorf("Invalid factory repo -- treating as devel project only")
-		return
+	for i := 0; i < len(develProjectPackages); i++ {
+		pkg := develProjectPackages[i]
+		meta, _ := obs.GetPackageMeta(prj, pkg)
+		if len(meta.ScmSync) > 0 {
+			if err2 := cloneDevel(git, "", pkg, meta.ScmSync); err2 != nil {
+				log.Panicln(err2)
+			}
+			git.GitExecOrPanic(pkg, "checkout", "-B", "main")
+			continue
+		} else {
+			common.PanicOnError(gitImporter(prj, pkg))
+			if out, err := git.GitExecWithOutput(pkg, "show-ref", "--branches"); err != nil || len(common.SplitStringNoEmpty(out, "\n")) == 0 {
+				log.Println(" *** no branches in package. removing")
+				develProjectPackages = slices.Delete(develProjectPackages, i, i+1)
+				i--
+				continue
+			}
+		}
+
+		// mark newer branch as main
+		branch := "factory"
+		if len(common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg, "rev-list", "^factory", "devel"), "\n")) > 0 {
+			log.Println(" *** pool branch 'devel' ahead. Switching branches.")
+			branch = "devel"
+		}
+		git.GitExecOrPanic(pkg, "checkout", "-B", "main", branch)
 	}
 
-	devel_project, err := devel_projects.GetDevelProject(pkg)
-	common.LogDebug("Devel project:", devel_project, err)
-	if err == common.DevelProjectNotFound {
-		// assume it's this project, maybe removed from factory
-		devel_project = prj
-	}
-	common.LogDebug("finding missing branches in", pkg, devel_project)
-	findMissingDevelBranch(git, pkg, devel_project)
-	return
-}
+	slices.SortFunc(factoryRepos, func(a, b *models.Repository) int {
+		if a.Name == b.Name {
+			orgOrderNo := func(org string) int {
+				switch org {
+				case "pool":
+					return 1
+				}
+				return 0 // current devel to clone
+			}
 
-func SetRepoOptions(repo *models.Repository) {
-	_, err := client.Repository.RepoEdit(repository.NewRepoEditParams().WithOwner(org).WithRepo(repo.Name).WithBody(
-		&models.EditRepoOption{
+			return orgOrderNo(a.Owner.UserName) - orgOrderNo(b.Owner.UserName)
+		}
+		return strings.Compare(a.Name, b.Name)
+	})
+	factoryRepos = slices.CompactFunc(factoryRepos, func(a, b *models.Repository) bool {
+		return a.Name == b.Name
+	})
+
+	for _, pkg := range factoryRepos {
+		var repo *models.Repository
+		if repoData, err := client.Repository.RepoGet(repository.NewRepoGetParams().WithOwner(org).WithRepo(pkg.Name), r.DefaultAuthentication); err != nil {
+			// update package
+			fork, err := client.Repository.CreateFork(repository.NewCreateForkParams().
+				WithOwner(pkg.Owner.UserName).
+				WithRepo(pkg.Name).
+				WithBody(&models.CreateForkOption{
+					Organization: org,
+				}), r.DefaultAuthentication)
+			if err != nil {
+				log.Panicln("Error while trying to create fork from", pkg.Owner.UserName, pkg.Name, "to", org, ":", err)
+			}
+
+			repo = fork.Payload
+		} else {
+			repo = repoData.Payload
+		}
+		//		branchName := repo.DefaultBranch
+
+		remotes := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg.Name, "remote", "show"), "\n")
+		if !slices.Contains(remotes, "develorigin") {
+			git.GitExecOrPanic(pkg.Name, "remote", "add", "develorigin", repo.SSHURL)
+			//			git.GitExecOrPanic(pkg.Name, "fetch", "devel")
+		}
+		if slices.Contains(remotes, "origin") {
+			git.GitExecOrPanic(pkg.Name, "lfs", "fetch", "--all")
+			git.GitExecOrPanic(pkg.Name, "lfs", "push", "develorigin", "--all")
+		}
+		git.GitExecOrPanic(pkg.Name, "push", "develorigin", "main", "-f")
+		git.GitExec(pkg.Name, "push", "develorigin", "--delete", "factory", "devel")
+		// git.GitExecOrPanic(pkg.Name, "checkout", "-B", "main", "devel/main")
+		_, err := client.Repository.RepoEdit(repository.NewRepoEditParams().WithOwner(org).WithRepo(repo.Name).WithBody(&models.EditRepoOption{
+			DefaultBranch:              "main",
+			DefaultMergeStyle:          "fast-forward-only",
 			HasPullRequests:            true,
 			HasPackages:                false,
 			HasReleases:                false,
@@ -290,306 +488,81 @@ func SetRepoOptions(repo *models.Repository) {
 			AllowRebaseUpdate:          false,
 			AllowManualMerge:           true,
 			AutodetectManualMerge:      true,
-			DefaultMergeStyle:          "fast-forward-only",
 			AllowRebase:                false,
 			DefaultAllowMaintainerEdit: true,
-			DefaultBranch:              "main",
-		}),
-		r.DefaultAuthentication,
-	)
-
-	if err != nil {
-		log.Panicln("Failed to adjust repository:", repo.Name, err)
-	}
-}
-
-func CreatePoolFork(factoryRepo *models.Repository) *models.Repository {
-	pkg := factoryRepo.Name
-	log.Println("factory fork creator for develProjectPackage:", pkg)
-	if repoData, err := client.Repository.RepoGet(repository.NewRepoGetParams().WithOwner(org).WithRepo(pkg), r.DefaultAuthentication); err != nil {
-		// update package
-		fork, err := client.Repository.CreateFork(repository.NewCreateForkParams().
-			WithOwner("pool").
-			WithRepo(factoryRepo.Name).
-			WithBody(&models.CreateForkOption{
-				Organization: org,
-			}), r.DefaultAuthentication)
-		if err != nil {
-			log.Panicln("Error while trying to create fork from 'pool'", pkg, "to", org, ":", err)
-		}
-
-		repo := fork.Payload
-		return repo
-	} else {
-		return repoData.Payload
-	}
-}
-
-func CreateDevelOnlyPackage(pkg string) *models.Repository {
-	log.Println("repo creator for develProjectPackage:", pkg)
-	if repoData, err := client.Repository.RepoGet(repository.NewRepoGetParams().WithOwner(org).WithRepo(giteaPackage(pkg)), r.DefaultAuthentication); err != nil {
-		giteaPkg := giteaPackage(pkg)
-		repoData, err := client.Organization.CreateOrgRepo(organization.NewCreateOrgRepoParams().WithOrg(org).WithBody(
-			&models.CreateRepoOption{
-				ObjectFormatName: "sha256",
-				AutoInit:         false,
-				Name:             &giteaPkg,
-				DefaultBranch:    "main",
-			}),
-			r.DefaultAuthentication,
-		)
+		}), r.DefaultAuthentication)
 
 		if err != nil {
-			log.Panicln("Error creating new package repository:", pkg, err)
+			log.Panicln("Failed to set default branch for package fork:", repo.Owner.UserName, "/", repo.Name, err)
 		}
-
-		repo := repoData.Payload
-		return repo
-	} else {
-		return repoData.Payload
 	}
-}
 
-func PushRepository(factoryRepo, develRepo *models.Repository, pkg string) (repo *models.Repository) {
-	//		branchName := repo.DefaultBranch
-	if factoryRepo != nil {
-		repo = CreatePoolFork(factoryRepo)
+	for _, pkg := range develProjectPackages {
+		var repo *models.Repository
+		if repoData, err := client.Repository.RepoGet(repository.NewRepoGetParams().WithOwner(org).WithRepo(pkg), r.DefaultAuthentication); err != nil {
+			_, err := client.Organization.CreateOrgRepo(organization.NewCreateOrgRepoParams().WithOrg(org).WithBody(
+				&models.CreateRepoOption{
+					ObjectFormatName: "sha256",
+					AutoInit:         false,
+					Name:             &pkg,
+					DefaultBranch:    "main",
+				}),
+				r.DefaultAuthentication,
+			)
 
-		/*
-			devel
-				for _, b := range branches {
-					if len(b) > 12 && b[0:12] == "develorigin/" {
-						b = b[12:]
-						if b == "factory" || b == "devel" {
-							git.GitExec(pkg, "push", "develorigin", "--delete", b)
-						}
-					}
-				}*/
-
-		//branches := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg.Name, "branch", "-r"), "\n")
-		/* factory
-		for _, b := range branches {
-			if len(b) > 12 && b[0:12] == "develorigin/" {
-				b = b[12:]
-				if b == "factory" || b == "devel" {
-					git.GitExec(pkg.Name, "push", "develorigin", "--delete", b)
-				}
+			if err != nil {
+				log.Panicln("Error creating new package repository:", pkg, err)
 			}
-		}
-		*/
-		// git.GitExecOrPanic(pkg.ame, "checkout", "-B", "main", "devel/main")
-	} else {
-		repo = CreateDevelOnlyPackage(pkg)
-	}
 
-	remotes := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg, "remote", "show"), "\n")
-	if !slices.Contains(remotes, "develorigin") {
-		git.GitExecOrPanic(pkg, "remote", "add", "develorigin", repo.SSHURL)
-		//			git.GitExecOrPanic(pkgName, "fetch", "devel")
-	}
-	if slices.Contains(remotes, "origin") {
-		git.GitExecOrPanic(pkg, "lfs", "fetch", "--all")
-		git.GitExecOrPanic(pkg, "lfs", "push", "develorigin", "--all")
-	}
+			ret, err := client.Repository.RepoEdit(repository.NewRepoEditParams().WithOwner(org).WithRepo(pkg).WithBody(
+				&models.EditRepoOption{
+					HasPullRequests:            true,
+					HasPackages:                false,
+					HasReleases:                false,
+					HasActions:                 false,
+					AllowMerge:                 true,
+					AllowRebaseMerge:           false,
+					AllowSquash:                false,
+					AllowFastForwardOnly:       true,
+					AllowRebaseUpdate:          false,
+					AllowManualMerge:           true,
+					AutodetectManualMerge:      true,
+					DefaultMergeStyle:          "fast-forward-only",
+					AllowRebase:                false,
+					DefaultAllowMaintainerEdit: true,
+				}),
+				r.DefaultAuthentication,
+			)
 
-	git.GitExecOrPanic(pkg, "push", "develorigin", "main", "-f")
-	SetRepoOptions(repo)
-	git.GitExec(pkg, "push", "develorigin", "--delete", "factory")
-	git.GitExec(pkg, "push", "develorigin", "--delete", "devel")
-	git.GitExec(pkg, "push", "develorigin", "--delete", "leap-16.0")
-	return repo
-}
-
-func importDevelRepoAndCheckHistory(pkg string, meta *common.PackageMeta) *models.Repository {
-	repo := CreateDevelOnlyPackage(pkg)
-	if _, err := os.Stat(filepath.Join(git.GetPath(), pkg)); os.IsNotExist(err) {
-		cloneDevel(git, "", pkg, repo.SSHURL, "develorigin", false) // in case we have imported
-	}
-
-	if CloneScmsync(pkg, meta) {
-		return repo
-	}
-	var p, dp string
-	factory_branch, fhe := git.GitRemoteHead(pkg, "develorigin", "factory")
-	if fhe == nil {
-		p = strings.TrimSpace(git.GitExecWithOutputOrPanic(pkg, "rev-list", "--max-parents=0", "--count", factory_branch))
-	} else {
-		common.LogError(fhe)
-	}
-	devel_branch, dhe := git.GitRemoteHead(pkg, "develorigin", "devel")
-	if dhe != nil {
-		devel_project, err := devel_projects.GetDevelProject(pkg)
-		common.LogDebug("Devel project:", devel_project, err)
-		if err == common.DevelProjectNotFound {
-			// assume it's this project, maybe removed from factory
-			devel_project = prj
-		}
-		common.LogDebug("finding missing branches in", pkg, devel_project)
-		findMissingDevelBranch(git, pkg, devel_project)
-		devel_branch, dhe = git.GitBranchHead(pkg, "devel")
-	}
-	if dhe == nil {
-		dp = strings.TrimSpace(git.GitExecWithOutputOrPanic(pkg, "rev-list", "--max-parents=0", "--count", devel_branch))
-	} else {
-		common.LogError(dhe)
-	}
-
-	// even if one parent for both, we need common ancestry, or we are comparing different things.
-	mb, mb_err := git.GitExecWithOutput(pkg, "merge-base", factory_branch, devel_branch)
-	mb = strings.TrimSpace(mb)
-
-	if p != "1" || dp != "1" || mb_err != nil || mb != factory_branch || mb != devel_branch {
-		common.LogInfo("Bad export found ... clearing", p, dp)
-		common.LogInfo("  merge branch:", mb, factory_branch, devel_branch, mb_err)
-		common.PanicOnError(os.RemoveAll(path.Join(git.GetPath(), pkg)))
-	}
-
-	if err := gitImporter("openSUSE:Factory", pkg); err != nil {
-		common.PanicOnError(gitImporter(prj, pkg))
-	}
-	if p := strings.TrimSpace(git.GitExecWithOutputOrPanic(pkg, "rev-list", "--max-parents=0", "--count", "factory")); p != "1" {
-		common.LogError("Failed to import package:", pkg)
-		common.PanicOnError(fmt.Errorf("Expecting 1 root in after devel import, but have %s", p))
-	}
-	if out, err := git.GitExecWithOutput(pkg, "show-ref", "--branches"); err != nil || len(common.SplitStringNoEmpty(out, "\n")) == 0 {
-		common.LogError(" *** no branches in package. removing")
-		return repo
-	}
-
-	return repo
-}
-
-func SetMainBranch(pkg string, meta *common.PackageMeta) {
-	// scnsync, follow that and don't care
-	common.LogDebug("Setting main branch...")
-	remotes := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg, "remote", "show"), "\n")
-	if slices.Contains(remotes, "origin") {
-		u, err := url.Parse(meta.ScmSync)
-		common.PanicOnError(err)
-		if len(u.Fragment) == 0 {
-			u.Fragment = "HEAD"
-		}
-		if err := git.GitExec(pkg, "checkout", "-B", "main", u.Fragment); err != nil {
-			git.GitExecOrPanic(pkg, "checkout", "-B", "main", "origin/"+u.Fragment)
-		}
-		return
-	}
-
-	// check if we have factory
-	if _, err := git.GitBranchHead(pkg, "factory"); err != nil {
-		if len(git.GitExecWithOutputOrPanic(pkg, "show-ref", "pool/factory")) > 20 {
-			git.GitExecOrPanic(pkg, "branch", "factory", "pool/factory")
-		}
-	}
-
-	// mark newer branch as main
-	branch := "factory"
-	if len(common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg, "rev-list", "^factory", "devel"), "\n")) > 0 {
-		branch = "devel"
-	}
-	common.LogInfo("setting main to", branch)
-	git.GitExecOrPanic(pkg, "checkout", "-B", "main", branch)
-}
-
-func ObsToRepoName(obspkg string) string {
-	return strings.ReplaceAll(obspkg, "+", "_")
-}
-
-func ImportSha1Sync(pkg string, url *url.URL) {
-	common.LogDebug("Converting SHA1", url.String())
-
-	branch := url.Fragment
-	url.Fragment = ""
-	p := path.Join(pkg, "sha1stuff")
-	common.PanicOnError(os.RemoveAll(path.Join(git.GetPath(), p)))
-	git.GitExecOrPanic(pkg, "clone", "--mirror", url.String(), "sha1stuff")
-	git.GitExecOrPanic(p, "fetch", "origin", branch)
-
-	gitexport := exec.Command("/usr/bin/git", "fast-export", "--signed-tags=strip", "--tag-of-filtered-object=drop", "--all")
-	gitexport.Dir = path.Join(git.GetPath(), p)
-	gitexportData, err := gitexport.Output()
-	common.LogDebug("Got export data size:", len(gitexportData))
-	common.PanicOnError(err)
-	gitimport := exec.Command("/usr/bin/git", "fast-import", "--allow-unsafe-features")
-	gitimport.Dir = path.Join(git.GetPath(), pkg)
-	gitimport.Stdin = bytes.NewReader(gitexportData)
-	data, err := gitimport.CombinedOutput()
-	common.LogError(string(data))
-	common.PanicOnError(err)
-	common.PanicOnError(os.RemoveAll(path.Join(git.GetPath(), p)))
-	git.GitExecOrPanic(pkg, "checkout", branch)
-}
-
-func LfsImport(pkg string) {
-	git.GitExecOrPanic(pkg, "lfs", "migrate", "import", "--everything",
-		"--include=*.7z,*.bsp,*.bz2,*.gem,*.gz,*.jar,*.lz,*.lzma,*.obscpio,*.oxt,*.pdf,*.png,*.rpm,*.tar,*.tbz,*.tbz2,*.tgz,*.ttf,*.txz,*.whl,*.xz,*.zip,*.zst")
-}
-
-func CloneScmsync(pkg string, meta *common.PackageMeta) bool {
-	if len(meta.ScmSync) > 0 {
-		u, _ := url.Parse(meta.ScmSync)
-		if remotes := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg, "remote", "show"), "\n"); !slices.Contains(remotes, "origin") {
-			branch := u.Fragment
-			if len(branch) == 0 {
-				branch = "HEAD"
+			if err != nil {
+				log.Panicln("Failed to adjust repository:", pkg, err)
 			}
-			u.Fragment = ""
-			git.GitExecOrPanic(pkg, "remote", "add", "origin", u.String())
-			u.Fragment = branch
-		}
-		if err := git.GitExec(pkg, "fetch", "origin"); err != nil && strings.Contains(err.Error(), "fatal: mismatched algorithms: client sha256; server sha1") {
-			ImportSha1Sync(pkg, u)
-		} else if err != nil {
-			panic(err)
+			repo = ret.Payload
+
+		} else {
+			repo = repoData.Payload
 		}
 
-		LfsImport(pkg)
-		return true
-	}
+		remotes := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(pkg, "remote", "show"), "\n")
+		if !slices.Contains(remotes, "develorigin") {
+			git.GitExecOrPanic(pkg, "remote", "add", "develorigin", repo.SSHURL)
+		}
+		if slices.Contains(remotes, "origin") {
+			git.GitExecOrPanic(pkg, "lfs", "fetch", "--all")
+			git.GitExecOrPanic(pkg, "lfs", "push", "develorigin", "--all")
+		}
+		git.GitExecOrPanic(pkg, "push", "develorigin", "main", "-f")
+		git.GitExec(pkg, "push", "develorigin", "--delete", "factory", "devel")
 
-	return false
-}
+		_, err := client.Repository.RepoEdit(repository.NewRepoEditParams().WithOwner(org).WithRepo(pkg).WithBody(&models.EditRepoOption{
+			DefaultBranch:     "main",
+			DefaultMergeStyle: "fast-forward-only",
+		}), r.DefaultAuthentication)
 
-func importRepo(pkg string) (BrokenFactoryPackage, FailedImport bool) {
-	BrokenFactoryPackage = false
-	FailedImport = false
-
-	var develRepo, factoryRepo *models.Repository
-
-	src_pkg_name := strings.Split(pkg, ":")
-	pkg = src_pkg_name[0]
-
-	meta, err := obs.GetPackageMeta(prj, pkg)
-	if err != nil {
-		meta, err = obs.GetPackageMeta(prj, pkg)
 		if err != nil {
-			log.Println("Error fetching pkg meta for:", prj, pkg, err)
+			log.Panicln("Failed to set default branch for package fork:", repo.Owner.UserName, "/", repo.Name, err)
 		}
 	}
-	if err != nil {
-		common.PanicOnError(err)
-	}
-	if meta == nil {
-		panic("package meta is nil...")
-	}
-
-	factoryRepo, err = importFactoryRepoAndCheckHistory(pkg, meta)
-	if factoryRepo != nil && err != nil {
-		BrokenFactoryPackage = true
-	}
-	if factoryRepo == nil && forceNonPoolPackages {
-		log.Println(" IGNORING and will create these as non-pool packages!")
-	}
-
-	if factoryRepo == nil || BrokenFactoryPackage {
-		develRepo = importDevelRepoAndCheckHistory(pkg, meta)
-	} else {
-		CloneScmsync(pkg, meta)
-	}
-
-	SetMainBranch(pkg, meta)
-	PushRepository(factoryRepo, develRepo, pkg)
-	return
 }
 
 func syncOrgTeams(groupName string, origTeam []common.PersonRepoMeta) []string {
@@ -680,7 +653,7 @@ func syncPackageCollaborators(pkg string, orig_uids []common.PersonRepoMeta) []s
 	missing := []string{}
 	uids := make([]common.PersonRepoMeta, len(orig_uids))
 	copy(uids, orig_uids)
-	collab, err := client.Repository.RepoListCollaborators(repository.NewRepoListCollaboratorsParams().WithOwner(org).WithRepo(giteaPackage(pkg)), r.DefaultAuthentication)
+	collab, err := client.Repository.RepoListCollaborators(repository.NewRepoListCollaboratorsParams().WithOwner(org).WithRepo(pkg), r.DefaultAuthentication)
 	if err != nil {
 		if errors.Is(err, &repository.RepoListCollaboratorsNotFound{}) {
 			return missing
@@ -701,7 +674,7 @@ func syncPackageCollaborators(pkg string, orig_uids []common.PersonRepoMeta) []s
 		log.Println("missing collabs for", pkg, ":", uids)
 	}
 	for _, u := range uids {
-		_, err := client.Repository.RepoAddCollaborator(repository.NewRepoAddCollaboratorParams().WithOwner(org).WithRepo(giteaPackage(pkg)).WithBody(&models.AddCollaboratorOption{
+		_, err := client.Repository.RepoAddCollaborator(repository.NewRepoAddCollaboratorParams().WithOwner(org).WithRepo(pkg).WithBody(&models.AddCollaboratorOption{
 			Permission: "write",
 		}).WithCollaborator(u.UserID), r.DefaultAuthentication)
 
@@ -732,11 +705,6 @@ func syncMaintainersToGitea(pkgs []string) {
 	missingDevs := []string{}
 	devs := []string{}
 
-	if len(prjMeta.ScmSync) > 0 {
-		common.LogInfo("Project already in Git. Maintainers must have been already synced. Skipping...")
-		return
-	}
-
 	for _, group := range prjMeta.Groups {
 		if group.GroupID == "factory-maintainers" {
 			log.Println("Ignoring factory-maintainers")
@@ -841,31 +809,20 @@ func createPrjGit() {
 			if err != nil {
 				log.Panicln(err)
 			}
-			file.WriteString("{\n   // Reference build project\n   \"ObsProject\": \"" + prj + "\",\n}\n")
+			file.WriteString("{\n   // Reference build project\n   \"ObsProject\": \""+prj+"\",\n}\n")
 			file.Close()
 			git.GitExecOrPanic(common.DefaultGitPrj, "add", "staging.config")
 
 			if file, err = os.Create(path.Join(git.GetPath(), common.DefaultGitPrj, "workflow.config")); err != nil {
 				log.Panicln(err)
 			}
-			file.WriteString("{\n    \"Workflows\": [\"direct\", \"pr\"],\n    \"Organization\": \"" + org + "\",\n}\n")
+			file.WriteString("{\n    \"Workflows\": [\"direct\", \"pr\"],\n    \"Organization\": \""+org+"\",\n}\n")
 			file.Close()
 			git.GitExecOrPanic(common.DefaultGitPrj, "add", "workflow.config")
 		}
 	}
 }
 
-func TrimMultibuildPackages(packages []string) []string {
-	for i := 0; i < len(packages); {
-		if strings.Contains(packages[i], ":") {
-			packages = slices.Delete(packages, i, i+1)
-		} else {
-			i++
-		}
-	}
-	return packages
-}
-
 var client *apiclient.GiteaAPI
 var r *transport.Runtime
 var git common.Git
@@ -900,19 +857,12 @@ func main() {
 	syncMaintainers := flags.Bool("sync-maintainers-only", false, "Sync maintainers to Gitea and exit")
 	flags.BoolVar(&forceBadPool, "bad-pool", false, "Force packages if pool has no branches due to bad import")
 	flags.BoolVar(&forceNonPoolPackages, "non-pool", false, "Allow packages that are not in pool to be created. WARNING: Can't add to factory later!")
-	specificPackages := flags.String("packages", "", "Process specific package, separated by commas, ignoring the others")
-	resumeAt := flags.String("resume", "", "Resume import at given pacakge")
-	syncPool := flags.Bool("sync-pool-only", false, "Force updates pool based on currrently imported project")
 
 	if help := flags.Parse(os.Args[1:]); help == flag.ErrHelp || flags.NArg() != 2 {
 		printHelp(helpString.String())
 		return
 	}
 
-	if DebugMode {
-		common.SetLoggingLevel(common.LogLevelDebug)
-	}
-
 	r = transport.New(*giteaHost, apiclient.DefaultBasePath, [](string){"https"})
 	r.DefaultAuthentication = transport.BearerToken(common.GetGiteaToken())
 	// r.SetDebug(true)
@@ -947,7 +897,13 @@ func main() {
 	prj = flags.Arg(0)
 	org = flags.Arg(1)
 	packages, err := runObsCommand("ls", prj)
-	packages = TrimMultibuildPackages(packages)
+	for i := 0; i < len(packages); {
+		if strings.Contains(packages[i], ":") {
+			packages = slices.Delete(packages, i, i+1)
+		} else {
+			i++
+		}
+	}
 
 	git, err = gh.CreateGitHandler(org)
 	if err != nil {
@@ -956,27 +912,6 @@ func main() {
 	defer git.Close()
 	log.Println(" - working directory:" + git.GetPath())
 
-	if *syncPool {
-		factory_pkgs, err := runObsCommand("ls", "openSUSE:Factory")
-		common.PanicOnError(err)
-		common.LogInfo("Syncing pool only...")
-		factory_pkgs = TrimMultibuildPackages(factory_pkgs)
-
-		for _, pkg := range packages {
-			if !slices.Contains(factory_pkgs, pkg) {
-				continue
-			}
-
-			repo, err := client.Repository.RepoGet(repository.NewRepoGetParams().WithOwner(org).WithRepo(ObsToRepoName(pkg)), r.DefaultAuthentication)
-			common.PanicOnError(err)
-
-			if !slices.Contains(common.SplitLines(git.GitExecWithOutputOrPanic(pkg, "remote")), "pool") {
-				git.GitExecOrPanic(pkg, "remote", "add", "pool", repo.Payload.SSHURL)
-			}
-			git.GitExecOrPanic(pkg, "fetch", "pool")
-		}
-	}
-
 	/*
 		for _, pkg := range packages {
 			if _, err := client.Organization.CreateOrgRepo(organization.NewCreateOrgRepoParams().WithOrg(org).WithBody(
@@ -1017,42 +952,12 @@ func main() {
 
 	if *purgeOnly {
 		log.Println("Purging repositories...")
-		pkgs := packages
-		if len(*specificPackages) > 0 {
-			pkgs = common.SplitStringNoEmpty(*specificPackages, ",")
-		}
-		for _, pkg := range pkgs {
-			client.Repository.RepoDelete(repository.NewRepoDeleteParams().WithOwner(org).WithRepo(giteaPackage(pkg)), r.DefaultAuthentication)
+		for _, pkg := range packages {
+			client.Repository.RepoDelete(repository.NewRepoDeleteParams().WithOwner(org).WithRepo(pkg), r.DefaultAuthentication)
 		}
 		os.Exit(10)
 	}
 
-	if len(*specificPackages) != 0 {
-		packages = common.SplitStringNoEmpty(*specificPackages, ",")
-	}
-	slices.Sort(packages)
-
-	BrokenOBSPackage := []string{}
-	FailedImport := []string{}
-	for _, pkg := range packages {
-		if len(*resumeAt) > 0 && strings.Compare(*resumeAt, pkg) > 0 {
-			common.LogDebug(pkg, "skipped due to resuming at", *resumeAt)
-			continue
-		}
-
-		b, f := importRepo(pkg)
-		if b {
-			BrokenOBSPackage = append(BrokenOBSPackage, pkg)
-		}
-		if f {
-			FailedImport = append(FailedImport, pkg)
-		}
-	}
-
+	importRepos(packages)
 	syncMaintainersToGitea(packages)
-
-	common.LogError("Have broken pool packages:", len(BrokenOBSPackage))
-	// common.LogError("Total pool packages:", len(factoryRepos))
-	common.LogError("Failed to import:", strings.Join(FailedImport, ","))
-	common.LogInfo("BROKEN Pool packages:", strings.Join(BrokenOBSPackage, "\n"))
 }

gitea_status_proxy/config.go

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

gitea_status_proxy/handlers.go

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

gitea_status_proxy/main.go

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

go.mod

@@ -16,8 +16,6 @@ require (
 
 require (
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-openapi/analysis v0.23.0 // indirect
@@ -30,7 +28,6 @@ require (
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/oklog/ulid v1.3.1 // indirect
-	github.com/redis/go-redis/v9 v9.11.0 // indirect
 	go.mongodb.org/mongo-driver v1.14.0 // indirect
 	go.opentelemetry.io/otel v1.24.0 // indirect
 	go.opentelemetry.io/otel/metric v1.24.0 // indirect

go.sum

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

group-review/README.md

@@ -15,23 +15,6 @@ Target Usage
 
 Projects where policy reviews are required.
 
-Configiuration
---------------
-
-Groups are defined in the workflow.config inside the project git. They take following options,
-
-{
-...
-ReviewGroups: [
-     {
-        "Name": "name of the group user",
-        "Reviewers": ["members", "of", "group"],
-        "Silent": (true, false) -- if true, do not explicitly require review requests of group members
-     },
-],
-...
-}
-
 Requirements
 ------------
   * Gitea token to:

group-review/main.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 	"time"
-	"unicode"
 
 	"src.opensuse.org/autogits/common"
 	"src.opensuse.org/autogits/common/gitea-generated/models"
@@ -22,10 +21,9 @@ var acceptRx *regexp.Regexp
 var rejectRx *regexp.Regexp
 var groupName string
 
-func InitRegex(newGroupName string) {
-	groupName = newGroupName
-	acceptRx = regexp.MustCompile("^:\\s*(LGTM|approved?)")
-	rejectRx = regexp.MustCompile("^:\\s*")
+func InitRegex(groupName string) {
+	acceptRx = regexp.MustCompile("\\s*:\\s*LGTM")
+	rejectRx = regexp.MustCompile("\\s*:\\s*")
 }
 
 func ParseReviewLine(reviewText string) (bool, string) {
@@ -36,18 +34,7 @@ func ParseReviewLine(reviewText string) (bool, string) {
 		return false, line
 	}
 
-	l := line[glen:]
-	for idx, r := range l {
-		if unicode.IsSpace(r) {
-			continue
-		} else if r == ':' {
-			return true, l[idx:]
-		} else {
-			return false, line
-		}
-	}
-
-	return false, line
+	return true, line[glen:]
 }
 
 func ReviewAccepted(reviewText string) bool {
@@ -205,14 +192,13 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 		return
 	}
 
-	groupConfig, err := config.GetReviewGroup(groupName)
+	requestReviewers, err := config.GetReviewGroupMembers(groupName)
 	if err != nil {
 		common.LogError(err)
 		return
 	}
 
 	// submitter cannot be reviewer
-	requestReviewers := groupConfig.Reviewers
 	requestReviewers = slices.DeleteFunc(requestReviewers, func(u string) bool { return u == pr.User.UserName })
 	//	pr.Head.Sha
 
@@ -247,7 +233,7 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 
 	// request group member reviews, if missing
 	common.LogDebug("  Review incomplete...")
-	if !groupConfig.Silent && len(requestReviewers) > 0 {
+	if len(requestReviewers) > 0 {
 		common.LogDebug("  Requesting reviews for:", requestReviewers)
 		if !common.IsDryRun {
 			if _, err := gitea.RequestReviews(pr, requestReviewers...); err != nil {
@@ -271,9 +257,6 @@ func ProcessNotifications(notification *models.NotificationThread, gitea common.
 
 	if !found_help_comment && !common.IsDryRun {
 		helpComment := fmt.Sprintln("Review by", groupName, "represents a group of reviewers:", strings.Join(requestReviewers, ", "), ". To review as part of this group, create a comment with contents @"+groupName+": LGTM on a separate line to accept a review. To request changes, write @"+groupName+": followed by reason for rejection. Do not use reviews to review as a group. Editing a comment invalidates that comment.")
-		if slices.Contains(groupConfig.Reviewers, pr.User.UserName) {
-			helpComment = helpComment + "\n\n" + fmt.Sprintln("Submitter is member of this review group, hence they are excluded from being one of the reviewers here")
-		}
 		gitea.AddComment(pr, helpComment)
 	}
 }
@@ -375,19 +358,19 @@ func main() {
 		config_modified: make(chan *common.AutogitConfig),
 	}
 
-	configUpdates := &common.RabbitMQGiteaEventsProcessor{
-		Orgs: []string{},
+	configUpdates := &common.ListenDefinitions{
+		RabbitURL: u,
+		Orgs:      []string{},
 		Handlers: map[string]common.RequestProcessor{
 			common.RequestType_Push: &config_update,
 		},
 	}
-	configUpdates.Connection().RabbitURL = u
 	for _, c := range configs {
 		if org, _, _ := c.GetPrjGit(); !slices.Contains(configUpdates.Orgs, org) {
 			configUpdates.Orgs = append(configUpdates.Orgs, org)
 		}
 	}
-	go common.ProcessRabbitMQEvents(configUpdates)
+	go configUpdates.ProcessRabbitMQEvents()
 
 	for {
 	config_update_loop:

group-review/main_test.go

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

obs-staging-bot/main.go

@@ -120,7 +120,7 @@ func ProcessBuildStatus(project, refProject *common.BuildResultList) BuildStatus
 	// the repositories should be setup equally between the projects. We
 	// need to verify that packages that are building in `refProject` are not
 	// failing in the `project`
-	BuildResultSorter := func(a, b *common.BuildResult) int {
+	BuildResultSorter := func(a, b common.BuildResult) int {
 		if c := strings.Compare(a.Repository, b.Repository); c != 0 {
 			return c
 		}
@@ -136,7 +136,7 @@ func ProcessBuildStatus(project, refProject *common.BuildResultList) BuildStatus
 		common.LogInfo("New package. Only need some success...")
 		SomeSuccess := false
 		for i := 0; i < len(project.Result); i++ {
-			repoRes := project.Result[i]
+			repoRes := &project.Result[i]
 			repoResStatus, ok := common.ObsRepoStatusDetails[repoRes.Code]
 			if !ok {
 				common.LogDebug("cannot find code:", repoRes.Code)
@@ -205,8 +205,8 @@ func ProcessBuildStatus(project, refProject *common.BuildResultList) BuildStatus
 	return BuildStatusSummaryFailed
 }
 
-func ProcessRepoBuildStatus(results, ref []*common.PackageBuildStatus) (status BuildStatusSummary, SomeSuccess bool) {
-	PackageBuildStatusSorter := func(a, b *common.PackageBuildStatus) int {
+func ProcessRepoBuildStatus(results, ref []common.PackageBuildStatus) (status BuildStatusSummary, SomeSuccess bool) {
+	PackageBuildStatusSorter := func(a, b common.PackageBuildStatus) int {
 		return strings.Compare(a.Package, b.Package)
 	}
 

obs-status-service/.gitignore

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

obs-status-service/main.go

@@ -22,13 +22,8 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
-	"io"
 	"log"
 	"net/http"
-	"os"
-	"slices"
-	"strings"
-	"time"
 
 	"src.opensuse.org/autogits/common"
 )
@@ -38,18 +33,27 @@ const (
 )
 
 var obs *common.ObsClient
+var debug bool
 
-func ProjectStatusSummarySvg(res []*common.BuildResult) []byte {
-	list := common.BuildResultList{
-		Result: res,
+func LogDebug(v ...any) {
+	if debug {
+		log.Println(v...)
 	}
-	pkgs := list.GetPackageList()
+}
+
+func ProjectStatusSummarySvg(project string) []byte {
+	res := GetCurrentStatus(project)
+	if res == nil {
+		return nil
+	}
+
+	pkgs := res.GetPackageList()
 	maxLen := 0
 	for _, p := range pkgs {
 		maxLen = max(maxLen, len(p))
 	}
 
-	width := float32(len(list.Result))*1.5 + float32(maxLen)*0.8
+	width := float32(len(res.Result))*1.5 + float32(maxLen)*0.8
 	height := 1.5*float32(maxLen) + 30
 
 	ret := bytes.Buffer{}
@@ -60,78 +64,21 @@ func ProjectStatusSummarySvg(res []*common.BuildResult) []byte {
 	ret.WriteString(`em" xmlns="http://www.w3.org/2000/svg">`)
 	ret.WriteString(`<defs>
 <g id="f"> <!-- failed -->
-  <rect width="8em" height="1.5em" fill="#800" />
+  <rect width="1em" height="1em" fill="#800" />
 </g>
 <g id="s"> <!--succeeded-->
-  <rect width="8em" height="1.5em" fill="#080" />
+  <rect width="1em" height="1em" fill="#080" />
 </g>
 <g id="buidling"> <!--building-->
-  <rect width="8em" height="1.5em" fill="#880" />
+  <rect width="1em" height="1em" fill="#880" />
 </g>
 </defs>`)
-
 	ret.WriteString(`<use href="#f" x="1em" y="2em"/>`)
 	ret.WriteString(`</svg>`)
 	return ret.Bytes()
 }
 
-func LinkToBuildlog(R *common.BuildResult, S *common.PackageBuildStatus) string {
-	if R != nil && S != nil {
-		switch S.Code {
-		case "succeeded", "failed", "building":
-			return "/buildlog/" + R.Project + "/" + S.Package + "/" + R.Repository + "/" + R.Arch
-		}
-	}
-	return ""
-}
-
-func PackageStatusSummarySvg(pkg string, res []*common.BuildResult) []byte {
-	// per repo, per arch status bins
-	repo_names := []string{}
-	package_names := []string{}
-	multibuild_prefix := pkg + ":"
-	for _, r := range res {
-		if pos, found := slices.BinarySearchFunc(repo_names, r.Repository, strings.Compare); !found {
-			repo_names = slices.Insert(repo_names, pos, r.Repository)
-		}
-
-		for _, p := range r.Status {
-			if p.Package == pkg || strings.HasPrefix(p.Package, multibuild_prefix) {
-				if pos, found := slices.BinarySearchFunc(package_names, p.Package, strings.Compare); !found {
-					package_names = slices.Insert(package_names, pos, p.Package)
-				}
-			}
-		}
-	}
-
-	ret := NewSvg()
-	for _, pkg = range package_names {
-		//		if len(package_names) > 1 {
-		ret.WriteTitle(pkg)
-		//		}
-
-		for _, name := range repo_names {
-			ret.WriteSubtitle(name)
-			// print all repo arches here and build results
-			for _, r := range res {
-				if r.Repository != name {
-					continue
-				}
-
-				for _, s := range r.Status {
-					if s.Package == pkg {
-						link := LinkToBuildlog(r, s)
-						ret.WritePackageStatus(link, r.Arch, s.Code, s.Details)
-					}
-				}
-			}
-		}
-	}
-
-	return ret.GenerateSvg()
-}
-
-func BuildStatusSvg(repo *common.BuildResult, status *common.PackageBuildStatus) []byte {
+func PackageStatusSummarySvg(status common.PackageBuildStatus) []byte {
 	buildStatus, ok := common.ObsBuildStatusDetails[status.Code]
 	if !ok {
 		buildStatus = common.ObsBuildStatusDetails["error"]
@@ -148,18 +95,12 @@ func BuildStatusSvg(repo *common.BuildResult, status *common.PackageBuildStatus)
 		}
 	}
 
-	buildlog := LinkToBuildlog(repo, status)
-	startTag := ""
-	endTag := ""
+	log.Println(status, " -> ", buildStatus)
 
-	if len(buildlog) > 0 {
-		startTag = "<a href=\"" + buildlog + "\">"
-		endTag = "</a>"
-	}
-
-	return []byte(`<svg version="2.0" width="8em" height="1.5em" xmlns="http://www.w3.org/2000/svg">` +
-		`<rect width="100%" height="100%" fill="` + fillColor + `"/>` + startTag +
-		`<text x="4em" y="1.1em" text-anchor="middle" fill="` + textColor + `">` + buildStatus.Code + `</text>` + endTag + `</svg>`)
+	return []byte(`<svg version="2.0" width="8em" height="1.5em" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="` + fillColor + `"/>
+  <text x="4em" y="1.1em" text-anchor="middle" fill="` + textColor + `">` + buildStatus.Code + `</text>
+</svg>`)
 }
 
 func main() {
@@ -167,119 +108,59 @@ func main() {
 	key := flag.String("key-file", "", "Private key for the TLS certificate")
 	listen := flag.String("listen", "[::1]:8080", "Listening string")
 	disableTls := flag.Bool("no-tls", false, "Disable TLS")
-	obsUrl := flag.String("obs-url", "https://api.opensuse.org", "OBS API endpoint for package buildlog information")
-	debug := flag.Bool("debug", false, "Enable debug logging")
-	//	RabbitMQHost := flag.String("rabbit-mq", "amqps://rabbit.opensuse.org", "RabbitMQ message bus server")
-	//	Topic := flag.String("topic", "opensuse.obs", "RabbitMQ topic prefix")
+	obsHost := flag.String("obs-host", "api.opensuse.org", "OBS API endpoint for package status information")
+	flag.BoolVar(&debug, "debug", false, "Enable debug logging")
 	flag.Parse()
 
-	if *debug {
-		common.SetLoggingLevel(common.LogLevelDebug)
-	}
-
-	// common.PanicOnError(common.RequireObsSecretToken())
+	common.PanicOnError(common.RequireObsSecretToken())
 
 	var err error
-	if obs, err = common.NewObsClient(*obsUrl); err != nil {
+	if obs, err = common.NewObsClient(*obsHost); err != nil {
 		log.Fatal(err)
 	}
 
-	if redisUrl := os.Getenv("REDIS"); len(redisUrl) > 0 {
-		RedisConnect(redisUrl)
-	} else {
-		common.LogError("REDIS needs to contains URL of the OBS Redis instance with login information")
-		return
-	}
-
-	go func() {
-		for {
-			if err := RescanRepositories(); err != nil {
-				common.LogError("Failed to rescan repositories.", err)
-			}
-			time.Sleep(time.Minute * 5)
-		}
-	}()
-
-	http.HandleFunc("GET /status/{Project}", func(res http.ResponseWriter, req *http.Request) {
-		obsPrj := req.PathValue("Project")
-		common.LogInfo("  request: GET /status/" + obsPrj)
+	http.HandleFunc("GET /{Project}", func(res http.ResponseWriter, req *http.Request) {
 		res.WriteHeader(http.StatusBadRequest)
 	})
-	http.HandleFunc("GET /status/{Project}/{Package}", func(res http.ResponseWriter, req *http.Request) {
-		obsPrj := req.PathValue("Project")
-		obsPkg := req.PathValue("Package")
-		common.LogInfo("  request: GET /status/" + obsPrj + "/" + obsPkg)
+	http.HandleFunc("GET /{Project}/{Package}", func(res http.ResponseWriter, req *http.Request) {
+		/*
+			obsPrj := req.PathValue("Project")
+			obsPkg := req.PathValue("Package")
 
-		status := FindAndUpdateProjectResults(obsPrj)
-		if len(status) == 0 {
-			res.WriteHeader(404)
-			return
-		}
-		svg := PackageStatusSummarySvg(obsPkg, status)
+			status, _ := PackageBuildStatus(obsPrj, obsPkg)
+			svg := PackageStatusSummarySvg(status)
+		*/
 
 		res.Header().Add("content-type", "image/svg+xml")
-		res.Header().Add("size", fmt.Sprint(len(svg)))
-		res.Write(svg)
+		//res.Header().Add("size", fmt.Sprint(len(svg)))
+		//res.Write(svg)
 	})
-	http.HandleFunc("GET /status/{Project}/{Package}/{Repository}", func(res http.ResponseWriter, req *http.Request) {
-		obsPrj := req.PathValue("Project")
-		obsPkg := req.PathValue("Package")
-		repo := req.PathValue("Repository")
-		common.LogInfo("  request: GET /status/" + obsPrj + "/" + obsPkg)
-
-		status := FindAndUpdateRepoResults(obsPrj, repo)
-		if len(status) == 0 {
-			res.WriteHeader(404)
-			return
-		}
-		svg := PackageStatusSummarySvg(obsPkg, status)
-
-		res.Header().Add("content-type", "image/svg+xml")
-		res.Header().Add("size", fmt.Sprint(len(svg)))
-		res.Write(svg)
-	})
-	http.HandleFunc("GET /status/{Project}/{Package}/{Repository}/{Arch}", func(res http.ResponseWriter, req *http.Request) {
+	http.HandleFunc("GET /{Project}/{Package}/{Repository}/{Arch}", func(res http.ResponseWriter, req *http.Request) {
 		prj := req.PathValue("Project")
 		pkg := req.PathValue("Package")
 		repo := req.PathValue("Repository")
 		arch := req.PathValue("Arch")
-		common.LogInfo("GET /status/" + prj + "/" + pkg + "/" + repo + "/" + arch)
 
 		res.Header().Add("content-type", "image/svg+xml")
 
-		for _, r := range FindAndUpdateProjectResults(prj) {
+		prjStatus := GetCurrentStatus(prj)
+		if prjStatus == nil {
+			return
+		}
+
+		for _, r := range prjStatus.Result {
 			if r.Arch == arch && r.Repository == repo {
-				if idx, found := slices.BinarySearchFunc(r.Status, &common.PackageBuildStatus{Package: pkg}, common.PackageBuildStatusComp); found {
-					res.Write(BuildStatusSvg(r, r.Status[idx]))
-					return
+				for _, status := range r.Status {
+					if status.Package == pkg {
+						res.Write(PackageStatusSummarySvg(status))
+						return
+					}
 				}
-				break
 			}
 		}
-
-		res.Write(BuildStatusSvg(nil, &common.PackageBuildStatus{Package: pkg, Code: "unknown"}))
 	})
-	http.HandleFunc("GET /buildlog/{Project}/{Package}/{Repository}/{Arch}", func(res http.ResponseWriter, req *http.Request) {
-		prj := req.PathValue("Project")
-		pkg := req.PathValue("Package")
-		repo := req.PathValue("Repository")
-		arch := req.PathValue("Arch")
 
-		res.Header().Add("location", "https://build.opensuse.org/package/live_build_log/"+prj+"/"+pkg+"/"+repo+"/"+arch)
-		res.WriteHeader(307)
-		return
-
-		//		status := GetDetailedBuildStatus(prj, pkg, repo, arch)
-		data, err := obs.BuildLog(prj, pkg, repo, arch)
-		if err != nil {
-			res.WriteHeader(http.StatusInternalServerError)
-			common.LogError("Failed to fetch build log for:", prj, pkg, repo, arch, err)
-			return
-		}
-		defer data.Close()
-
-		io.Copy(res, data)
-	})
+	go ProcessUpdates()
 
 	if *disableTls {
 		log.Fatal(http.ListenAndServe(*listen, nil))

obs-status-service/main_test.go

@@ -1,82 +0,0 @@
-package main
-
-import (
-	"os"
-	"testing"
-
-	"src.opensuse.org/autogits/common"
-)
-
-func TestStatusSvg(t *testing.T) {
-	os.WriteFile("teststatus.svg", BuildStatusSvg(nil, &common.PackageBuildStatus{
-		Package: "foo",
-		Code:    "succeeded",
-		Details: "more success here",
-	}), 0o777)
-	data := []*common.BuildResult{
-		{
-			Project:    "project:foo",
-			Repository: "repo1",
-			Arch:       "x86_64",
-			Status: []*common.PackageBuildStatus{
-				{
-					Package: "pkg1",
-					Code:    "succeeded",
-				},
-				{
-					Package: "pkg2",
-					Code:    "failed",
-				},
-			},
-		},
-		{
-			Project:    "project:foo",
-			Repository: "repo1",
-			Arch:       "s390x",
-			Status: []*common.PackageBuildStatus{
-				{
-					Package: "pkg1",
-					Code:    "succeeded",
-				},
-				{
-					Package: "pkg2",
-					Code:    "unresolveable",
-				},
-			},
-		},
-		{
-			Project:    "project:foo",
-			Repository: "repo1",
-			Arch:       "i586",
-			Status: []*common.PackageBuildStatus{
-				{
-					Package: "pkg1",
-					Code:    "succeeded",
-				},
-				{
-					Package: "pkg2",
-					Code:    "blocked",
-					Details: "foo bar is why",
-				},
-			},
-		},
-		{
-			Project:    "project:foo",
-			Repository: "TW",
-			Arch:       "s390",
-			Status: []*common.PackageBuildStatus{
-				{
-					Package: "pkg1",
-					Code:    "excluded",
-				},
-				{
-					Package: "pkg2",
-					Code:    "failed",
-				},
-			},
-		},
-	}
-
-	os.WriteFile("testpackage.svg", PackageStatusSummarySvg("pkg2", data), 0o777)
-	os.WriteFile("testproject.svg", ProjectStatusSummarySvg(data), 0o777)
-}

obs-status-service/redis.go

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

obs-status-service/status.go

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

obs-status-service/status_test.go

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

obs-status-service/svg.go

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

workflow-direct/README.md

@@ -7,24 +7,14 @@ Areas of responsibility
 1. Keep ProjectGit in sync with packages in the organization
    * on pushes to package, updates the submodule commit id
      to the default branch HEAD (as configured in Gitea)
-   * on repository adds, creates a new submodule (if non empty)
-   * on repository removal, removes the submodule
+   * on package adds, creates a new submodule
+   * on package 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.
+2. Assumes:
+   * config.GitProjectName == project name (default: `_ObsPrj`)
+   * Other repositories == packages (similar to OBS project)
+   * config.Branch == "" => default branch from Gitea
 
-Configuration
--------------
-
-Uses `workflow.config` for configuration. Parameters
-
-* _Workflows_: ["direct"] -- direct entry enables direct workflow. **Mandatory**
-* _Organization_: organization that holds all the packages. **Mandatory**
-* _Branch_: branch updated in repo's, or blank for default package branch
-* _GitProjectName_: package in above org, or `org/package#branch` for PrjGit. By default assumes `_ObsPrj` with default branch and in the `Organization`
-
-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.
 
 Target Usage
 ------------

workflow-direct/main.go

@@ -526,7 +526,7 @@ func main() {
 		log.Fatal(err)
 	}
 
-	defs := &common.RabbitMQGiteaEventsProcessor{}
+	var defs common.ListenDefinitions
 	var err error
 
 	if len(*basePath) == 0 {
@@ -557,7 +557,7 @@ func main() {
 			}
 			log.Println("*** Reconfiguring ***")
 			updateConfiguration(*configFilename, &defs.Orgs)
-			defs.Connection().UpdateTopics(defs)
+			defs.UpdateTopics()
 		}
 	}()
 	signal.Notify(signalChannel, syscall.SIGHUP)
@@ -573,17 +573,18 @@ func main() {
 
 	updateConfiguration(*configFilename, &defs.Orgs)
 
-	defs.Connection().RabbitURL, err = url.Parse(*rabbitUrl)
+	defs.GitAuthor = GitAuthor
+	defs.RabbitURL, err = url.Parse(*rabbitUrl)
 	if err != nil {
 		log.Panicf("cannot parse server URL. Err: %#v\n", err)
 	}
 
 	go consistencyCheckProcess()
-	log.Println("defs:", *defs)
+	log.Println("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))
+	log.Fatal(defs.ProcessRabbitMQEvents())
 }

workflow-pr/README.md

@@ -23,18 +23,16 @@ Any project (devel, etc) that accepts PR
 Config file
 -----------
 JSON
-* _Workflows_: ["pr"] -- pr entry enables pr workflow. **Mandatory**
-* _Organization_: organization that holds all the packages **Mandatory**
-* _Branch_: branch updated in repo's **Mandatory**
-* _GitProjectName_: package in above org, or `org/package#branch` for PrjGit. By default assumes `_ObsPrj` with default branch and in the `Organization`
+* _Workflows_: "pr" -- pr workflow enabled
+* _Organization_: organization that holds all the packages
+* _Branch_: branch updated in repo's
+* _GitProjectName_: package in above org, or `org/package` for PrjGit
 * _Reviewers_: accounts associated with mandatory reviews for PrjGit. Can trigger additional
                review requests for PrjGit or associated PkgGit repos. Only when all reviews are
                satisfied, will the PrjGit PR be merged. See Reviewers below.
 * _ManualMergeOnly_: (true, false) only merge if "merge ok" comment/review by package or project maintainers or reviewers
 * _ManualMergeProject_: (true, false) only merge if "merge ok" by project maintainers or reviewers
-* _ReviewRequired_: (true, false) ignores that submitter is a maintainer and require a review from other maintainer IFF available
 
-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:
 
     [

workflow-pr/main.go

@@ -121,12 +121,6 @@ func main() {
 			req.configuredRepos[c.Organization] = configs
 
 			orgs = append(orgs, c.Organization)
-
-			// add project git organization, if different
-			if prjOrg, _, _ := c.GetPrjGit(); prjOrg != c.Organization {
-				orgs = append(orgs, prjOrg)
-				req.configuredRepos[prjOrg] = configs
-			}
 		}
 	}
 
@@ -168,17 +162,17 @@ func main() {
 	checker := CreateDefaultStateChecker(*checkOnStart, req, Gitea, time.Duration(*checkIntervalHours)*time.Hour)
 	go checker.ConsistencyCheckProcess()
 
-	listenDefs := &common.RabbitMQGiteaEventsProcessor{
-		Orgs: orgs,
+	listenDefs := common.ListenDefinitions{
+		Orgs:      orgs,
+		GitAuthor: GitAuthor,
 		Handlers: map[string]common.RequestProcessor{
 			common.RequestType_PR:               req,
 			common.RequestType_PRSync:           req,
 			common.RequestType_PRReviewAccepted: req,
 			common.RequestType_PRReviewRejected: req,
-			common.RequestType_IssueComment:     req,
 		},
 	}
-	listenDefs.Connection().RabbitURL, _ = url.Parse(*rabbitUrl)
+	listenDefs.RabbitURL, _ = url.Parse(*rabbitUrl)
 
-	common.PanicOnError(common.ProcessRabbitMQEvents(listenDefs))
+	common.PanicOnError(listenDefs.ProcessRabbitMQEvents())
 }

workflow-pr/mock/pr_processor.go

@@ -1,10 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: pr_processor.go
-//
-// Generated by this command:
-//
-//	mockgen -source=pr_processor.go -destination=mock/pr_processor.go -typed
-//
-
-// Package mock_main is a generated GoMock package.
-package mock_main

workflow-pr/mock/state_checker.go

@@ -1,157 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: state_checker.go
-//
-// Generated by this command:
-//
-//	mockgen -source=state_checker.go -destination=../mock/state_checker.go -typed -package mock_main
-//
-
-// Package mock_main is a generated GoMock package.
-package mock_main
-
-import (
-	reflect "reflect"
-
-	gomock "go.uber.org/mock/gomock"
-	common "src.opensuse.org/autogits/common"
-	interfaces "src.opensuse.org/autogits/workflow-pr/interfaces"
-)
-
-// MockStateChecker is a mock of StateChecker interface.
-type MockStateChecker struct {
-	ctrl     *gomock.Controller
-	recorder *MockStateCheckerMockRecorder
-	isgomock struct{}
-}
-
-// MockStateCheckerMockRecorder is the mock recorder for MockStateChecker.
-type MockStateCheckerMockRecorder struct {
-	mock *MockStateChecker
-}
-
-// NewMockStateChecker creates a new mock instance.
-func NewMockStateChecker(ctrl *gomock.Controller) *MockStateChecker {
-	mock := &MockStateChecker{ctrl: ctrl}
-	mock.recorder = &MockStateCheckerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockStateChecker) EXPECT() *MockStateCheckerMockRecorder {
-	return m.recorder
-}
-
-// CheckRepos mocks base method.
-func (m *MockStateChecker) CheckRepos() error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CheckRepos")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// CheckRepos indicates an expected call of CheckRepos.
-func (mr *MockStateCheckerMockRecorder) CheckRepos() *MockStateCheckerCheckReposCall {
-	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRepos", reflect.TypeOf((*MockStateChecker)(nil).CheckRepos))
-	return &MockStateCheckerCheckReposCall{Call: call}
-}
-
-// MockStateCheckerCheckReposCall wrap *gomock.Call
-type MockStateCheckerCheckReposCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockStateCheckerCheckReposCall) Return(arg0 error) *MockStateCheckerCheckReposCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockStateCheckerCheckReposCall) Do(f func() error) *MockStateCheckerCheckReposCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStateCheckerCheckReposCall) DoAndReturn(f func() error) *MockStateCheckerCheckReposCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
-}
-
-// ConsistencyCheckProcess mocks base method.
-func (m *MockStateChecker) ConsistencyCheckProcess() error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConsistencyCheckProcess")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ConsistencyCheckProcess indicates an expected call of ConsistencyCheckProcess.
-func (mr *MockStateCheckerMockRecorder) ConsistencyCheckProcess() *MockStateCheckerConsistencyCheckProcessCall {
-	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsistencyCheckProcess", reflect.TypeOf((*MockStateChecker)(nil).ConsistencyCheckProcess))
-	return &MockStateCheckerConsistencyCheckProcessCall{Call: call}
-}
-
-// MockStateCheckerConsistencyCheckProcessCall wrap *gomock.Call
-type MockStateCheckerConsistencyCheckProcessCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockStateCheckerConsistencyCheckProcessCall) Return(arg0 error) *MockStateCheckerConsistencyCheckProcessCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockStateCheckerConsistencyCheckProcessCall) Do(f func() error) *MockStateCheckerConsistencyCheckProcessCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStateCheckerConsistencyCheckProcessCall) DoAndReturn(f func() error) *MockStateCheckerConsistencyCheckProcessCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
-}
-
-// VerifyProjectState mocks base method.
-func (m *MockStateChecker) VerifyProjectState(configs *common.AutogitConfig) ([]*interfaces.PRToProcess, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "VerifyProjectState", configs)
-	ret0, _ := ret[0].([]*interfaces.PRToProcess)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// VerifyProjectState indicates an expected call of VerifyProjectState.
-func (mr *MockStateCheckerMockRecorder) VerifyProjectState(configs any) *MockStateCheckerVerifyProjectStateCall {
-	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyProjectState", reflect.TypeOf((*MockStateChecker)(nil).VerifyProjectState), configs)
-	return &MockStateCheckerVerifyProjectStateCall{Call: call}
-}
-
-// MockStateCheckerVerifyProjectStateCall wrap *gomock.Call
-type MockStateCheckerVerifyProjectStateCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockStateCheckerVerifyProjectStateCall) Return(arg0 []*interfaces.PRToProcess, arg1 error) *MockStateCheckerVerifyProjectStateCall {
-	c.Call = c.Call.Return(arg0, arg1)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockStateCheckerVerifyProjectStateCall) Do(f func(*common.AutogitConfig) ([]*interfaces.PRToProcess, error)) *MockStateCheckerVerifyProjectStateCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStateCheckerVerifyProjectStateCall) DoAndReturn(f func(*common.AutogitConfig) ([]*interfaces.PRToProcess, error)) *MockStateCheckerVerifyProjectStateCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
-}

workflow-pr/pr_processor.go

@@ -11,44 +11,13 @@ import (
 
 	"github.com/opentracing/opentracing-go/log"
 	"src.opensuse.org/autogits/common"
-	"src.opensuse.org/autogits/common/gitea-generated/client/repository"
 	"src.opensuse.org/autogits/common/gitea-generated/models"
 )
 
-func prGitBranchNameForPR(repo string, prNo int64) string {
+func prGitBranchNameForPR(repo string, prNo int) string {
 	return fmt.Sprintf("PR_%s#%d", repo, prNo)
 }
 
-func PrjGitDescription(prset *common.PRSet) (title string, desc string) {
-	title_refs := make([]string, 0, len(prset.PRs)-1)
-	refs := make([]string, 0, len(prset.PRs)-1)
-
-	for _, pr := range prset.PRs {
-		if prset.IsPrjGitPR(pr.PR) {
-			continue
-		}
-		org, repo, idx := pr.PRComponents()
-
-		title_refs = append(title_refs, repo)
-		ref := fmt.Sprintf(common.PrPattern, org, repo, idx)
-		refs = append(refs, ref)
-	}
-
-	title = "Forwarded PRs: " + strings.Join(title_refs, ", ")
-	desc = fmt.Sprintf("This is a forwarded pull request by %s\nreferencing the following pull request(s):\n\n", GitAuthor) + strings.Join(refs, "\n") + "\n"
-
-	if prset.Config.ManualMergeOnly {
-		desc = desc + "\n###  ManualMergeOnly enabled. To merge, 'merge ok' is required in either the project PR or every package PR."
-	}
-	if prset.Config.ManualMergeProject {
-		desc = desc + "\n###  ManualMergeProject enabled. To merge, 'merge ok' is required by project maintainer in the project PR."
-	}
-	if !prset.Config.ManualMergeOnly && !prset.Config.ManualMergeProject {
-		desc = desc + "\n###  Automatic merge enabled. This will merge when all review requirements are satisfied."
-	}
-	return
-}
-
 func verifyRepositoryConfiguration(repo *models.Repository) error {
 	if repo.AutodetectManualMerge && repo.AllowManualMerge {
 		return nil
@@ -77,19 +46,19 @@ type PRProcessor struct {
 	git    common.Git
 }
 
-func AllocatePRProcessor(req *models.PullRequest, configs common.AutogitConfigs) (*PRProcessor, error) {
-	org := req.Base.Repo.Owner.UserName
-	repo := req.Base.Repo.Name
-	id := req.Index
+func AllocatePRProcessor(req *common.PullRequestWebhookEvent, configs common.AutogitConfigs) (*PRProcessor, error) {
+	org := req.Pull_Request.Base.Repo.Owner.Username
+	repo := req.Pull_Request.Base.Repo.Name
+	id := req.Pull_Request.Number
 
-	branch := req.Base.Ref
+	branch := req.Pull_Request.Base.Ref
 
 	PRstr := fmt.Sprintf("%s/%s#%d", org, repo, id)
 	common.LogInfo("*** Starting processing PR:", PRstr, "branch:", branch)
 
 	config := configs.GetPrjGitConfig(org, repo, branch)
 	if config == nil {
-		if req.Base.Repo.DefaultBranch == branch {
+		if req.Pull_Request.Base.Repo.Default_Branch == branch {
 			common.LogDebug("Default branch submission...", org, repo)
 			config = configs.GetPrjGitConfig(org, repo, "")
 		}
@@ -101,8 +70,8 @@ func AllocatePRProcessor(req *models.PullRequest, configs common.AutogitConfigs)
 
 	common.LogDebug("found config", config)
 	if config == nil {
-		common.LogError("Cannot find config for branch '%s'", req.Base.Ref)
-		return nil, fmt.Errorf("Cannot find config for branch '%s'", req.Base.Ref)
+		common.LogError("Cannot find config for branch '%s'", req.Pull_Request.Base.Ref)
+		return nil, fmt.Errorf("Cannot find config for branch '%s'", req.Pull_Request.Base.Ref)
 	}
 
 	git, err := GitHandler.CreateGitHandler(config.Organization)
@@ -121,20 +90,24 @@ func AllocatePRProcessor(req *models.PullRequest, configs common.AutogitConfigs)
 	}, nil
 }
 
-func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
+func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) ([]string, []string, error) {
 	git := pr.git
 	subList, err := git.GitSubmoduleList(common.DefaultGitPrj, "HEAD")
 	if err != nil {
 		common.LogError("Error fetching submodule list for PrjGit", err)
-		return err
+		return nil, nil, err
 	}
 
+	refs := make([]string, 0, len(prset.PRs))
+	title_refs := make([]string, 0, len(prset.PRs))
 	for _, pr := range prset.PRs {
 		if prset.IsPrjGitPR(pr.PR) {
 			continue
 		}
 
-		org, repo, idx := pr.PRComponents()
+		org := pr.PR.Base.Repo.Owner.UserName
+		repo := pr.PR.Base.Repo.Name
+		idx := pr.PR.Index
 		prHead := pr.PR.Head.Sha
 		revert := false
 
@@ -145,7 +118,7 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 				var valid bool
 				if prHead, valid = git.GitSubmoduleCommitId(common.DefaultGitPrj, repo, prjGitPR.PR.MergeBase); !valid {
 					common.LogError("Failed fetching original submodule commit id for repo")
-					return err
+					return nil, nil, err
 				}
 			}
 			revert = true
@@ -162,6 +135,9 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 
 					if revert {
 						commitMsg = fmt.Sprintln("auto-created for", repo, "\n\nThis commit was autocreated by", GitAuthor, "removing\n", ref)
+					} else {
+						refs = append(refs, ref)
+						title_refs = append(title_refs, repo)
 					}
 
 					updateSubmoduleInPR(submodulePath, prHead, git)
@@ -180,7 +156,7 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 			common.LogError("Failed to find expected repo:", repo)
 		}
 	}
-	return nil
+	return title_refs, refs, nil
 }
 
 func (pr *PRProcessor) CreatePRjGitPR(prjGitPRbranch string, prset *common.PRSet) error {
@@ -200,7 +176,8 @@ func (pr *PRProcessor) CreatePRjGitPR(prjGitPRbranch string, prset *common.PRSet
 		common.LogError("Failed to fetch PrjGit branch", prjGitPRbranch, err)
 		return err
 	}
-	if err := pr.SetSubmodulesToMatchPRSet(prset); err != nil {
+	title_refs, refs, err := pr.SetSubmodulesToMatchPRSet(prset)
+	if err != nil {
 		return err
 	}
 	newHeadCommit, err := git.GitBranchHead(common.DefaultGitPrj, prjGitPRbranch)
@@ -209,13 +186,12 @@ func (pr *PRProcessor) CreatePRjGitPR(prjGitPRbranch string, prset *common.PRSet
 		return err
 	}
 
-	if !common.IsDryRun {
-		if headCommit != newHeadCommit {
-			common.PanicOnError(git.GitExec(common.DefaultGitPrj, "push", RemoteName, "+HEAD:"+prjGitPRbranch))
-		}
-
-		title, desc := PrjGitDescription(prset)
-		pr, err := Gitea.CreatePullRequestIfNotExist(PrjGit, prjGitPRbranch, PrjGitBranch, title, desc)
+	if !common.IsDryRun && headCommit != newHeadCommit {
+		common.PanicOnError(git.GitExec(common.DefaultGitPrj, "push", RemoteName, "+HEAD:"+prjGitPRbranch))
+		pr, err := Gitea.CreatePullRequestIfNotExist(PrjGit, prjGitPRbranch, PrjGitBranch,
+			"Forwarded PRs: "+strings.Join(title_refs, ", "),
+			fmt.Sprintf("This is a forwarded pull request by %s\nreferencing the following pull request(s):\n\n", GitAuthor)+strings.Join(refs, ", "),
+		)
 		if err != nil {
 			common.LogError("Error creating PrjGit PR:", err)
 			return err
@@ -271,10 +247,10 @@ func (pr *PRProcessor) UpdatePrjGitPR(prset *common.PRSet) error {
 	PrjGitPR.RemoteName, err = git.GitClone(common.DefaultGitPrj, prjGitPRbranch, PrjGit.SSHURL)
 	common.PanicOnError(err)
 	git.GitExecOrPanic(common.DefaultGitPrj, "fetch", PrjGitPR.RemoteName, PrjGitBranch)
+	ExpectedMergeCommit, err := git.GitRemoteHead(common.DefaultGitPrj, PrjGitPR.RemoteName, PrjGitBranch)
 
 	forcePush := false
-	// trust Gitea here on mergeability
-	if !PrjGitPR.PR.Mergeable {
+	if ExpectedMergeCommit != PrjGitPR.PR.MergeBase {
 		common.PanicOnError(pr.RebaseAndSkipSubmoduleCommits(prset, PrjGitBranch))
 		forcePush = true
 	}
@@ -284,7 +260,8 @@ func (pr *PRProcessor) UpdatePrjGitPR(prset *common.PRSet) error {
 		common.LogError("Failed to fetch PrjGit branch", prjGitPRbranch, err)
 		return err
 	}
-	if err := pr.SetSubmodulesToMatchPRSet(prset); err != nil {
+	title_refs, refs, err := pr.SetSubmodulesToMatchPRSet(prset)
+	if err != nil {
 		return err
 	}
 	newHeadCommit, err := git.GitBranchHead(common.DefaultGitPrj, prjGitPRbranch)
@@ -293,41 +270,39 @@ func (pr *PRProcessor) UpdatePrjGitPR(prset *common.PRSet) error {
 		return err
 	}
 
-	if !common.IsDryRun {
-		if headCommit != newHeadCommit {
-			params := []string{"push", PrjGitPR.RemoteName, "+HEAD:" + prjGitPRbranch}
-			if forcePush {
-				params = slices.Insert(params, 1, "-f")
-			}
-			common.PanicOnError(git.GitExec(common.DefaultGitPrj, params...))
+	if !common.IsDryRun && headCommit != newHeadCommit {
+		params := []string{"push", PrjGitPR.RemoteName, "+HEAD:" + prjGitPRbranch}
+		if forcePush {
+			params = slices.Insert(params, 1, "-f")
 		}
+		common.PanicOnError(git.GitExec(common.DefaultGitPrj, params...))
 
 		// update PR
-		PrjGitTitle, PrjGitBody := PrjGitDescription(prset)
-		if PrjGitPR.PR.Body != PrjGitBody || PrjGitPR.PR.Title != PrjGitTitle {
-			Gitea.UpdatePullRequest(PrjGit.Owner.UserName, PrjGit.Name, PrjGitPR.PR.Index, &models.EditPullRequestOption{
-				RemoveDeadline: true,
-				Title:          PrjGitTitle,
-				Body:           PrjGitBody,
-			})
-		}
+		PrjGitTitle := "Forwarded PRs: " + strings.Join(title_refs, ", ")
+		PrjGitBody := fmt.Sprintf("This is a forwarded pull request by %s\nreferencing the following pull request(s):\n\n", GitAuthor) + strings.Join(refs, ", ")
+
+		Gitea.UpdatePullRequest(PrjGit.Owner.UserName, PrjGit.Name, PrjGitPR.PR.Index, &models.EditPullRequestOption{
+			RemoveDeadline: true,
+			Title:          PrjGitTitle,
+			Body:           PrjGitBody,
+		})
 	}
 	return nil
 }
 
-func (pr *PRProcessor) Process(req *models.PullRequest) error {
+func (pr *PRProcessor) Process(req *common.PullRequestWebhookEvent) error {
 	config := pr.config
 	git := pr.git
 
 	// requests against project are not handled here
-	common.LogInfo("processing opened PR:", req.URL)
-	prOrg := req.Base.Repo.Owner.UserName
-	prRepo := req.Base.Repo.Name
-	prNo := req.Index
+	common.LogInfo("processing opened PR:", req.Pull_Request.Url)
+	prOrg := req.Pull_Request.Base.Repo.Owner.Username
+	prRepo := req.Pull_Request.Base.Repo.Name
+	prNo := int(req.Pull_Request.Number)
 
 	common.LogError(req)
 
-	prset, err := common.FetchPRSet(CurrentUser.UserName, Gitea, prOrg, prRepo, prNo, config)
+	prset, err := common.FetchPRSet(CurrentUser.UserName, Gitea, prOrg, prRepo, req.Number, config)
 	if err != nil {
 		common.LogError("Cannot fetch PRSet:", err)
 		return err
@@ -347,66 +322,21 @@ func (pr *PRProcessor) Process(req *models.PullRequest) error {
 		prjGitPRbranch = prjGitPR.PR.Head.Name
 
 		if prjGitPR.PR.State != "open" {
-			if prjGitPR.PR.HasMerged {
-				// update branches in project
-				prjGitPR.RemoteName, err = git.GitClone(common.DefaultGitPrj, prjGitPRbranch, prjGitPR.PR.Base.Repo.SSHURL)
-				common.PanicOnError(err)
-
-				old_pkgs, err := git.GitSubmoduleList(common.DefaultGitPrj, prjGitPR.PR.MergeBase)
-				common.PanicOnError(err)
-				new_pkgs, err := git.GitSubmoduleList(common.DefaultGitPrj, prjGitPRbranch)
-				common.PanicOnError(err)
-
-				pkgs := make(map[string]string)
-				for pkg, old_commit := range old_pkgs {
-					if new_commit, found := new_pkgs[pkg]; found {
-						// pkg modified
-						if new_commit != old_commit {
-							pkgs[pkg] = new_commit
-						}
-					} else { // not found, pkg removed
-						pkgs[pkg] = ""
-					}
-				}
-				for pkg, commit := range new_pkgs {
-					if _, found := old_pkgs[pkg]; !found {
-						// pkg added
-						pkgs[pkg] = commit
-					}
-				}
-
-				PrjGitSubmoduleCheck(config, git, common.DefaultGitPrj, pkgs)
-			}
-
-			// manually merge or close entire prset that is still open
+			// close entire prset
+			common.LogInfo("PR State is closed:", prjGitPR.PR.State)
 			for _, pr := range prset.PRs {
 				if pr.PR.State == "open" {
-					org, repo, idx := pr.PRComponents()
-					if prjGitPR.PR.HasMerged {
-						Gitea.AddComment(pr.PR, "This PR is merged via the associated Project PR.")
-						err = Gitea.ManualMergePR(org, repo, idx, pr.PR.Head.Sha, false)
-						if _, ok := err.(*repository.RepoMergePullRequestConflict); !ok {
-							common.PanicOnError(err)
-						}
-					} else {
-						Gitea.AddComment(pr.PR, "Closing here because the associated Project PR has been closed.")
-						Gitea.UpdatePullRequest(org, repo, idx, &models.EditPullRequestOption{
-							State: "closed",
-						})
-					}
+					org := pr.PR.Base.Repo.Owner.UserName
+					repo := pr.PR.Base.Repo.Name
+					idx := pr.PR.Index
+					Gitea.UpdatePullRequest(org, repo, idx, &models.EditPullRequestOption{
+						State: "closed",
+					})
 				}
 			}
 			return nil
 		}
 
-		if len(prset.PRs) > 1 {
-			for _, pr := range prset.PRs {
-				if prset.IsPrjGitPR(pr.PR) {
-					continue
-				}
-			}
-		}
-
 		if err = pr.UpdatePrjGitPR(prset); err != nil {
 			return err
 		}
@@ -517,23 +447,7 @@ type RequestProcessor struct {
 	configuredRepos map[string][]*common.AutogitConfig
 }
 
-func ProcesPullRequest(pr *models.PullRequest, configs []*common.AutogitConfig) error {
-	if len(configs) < 1 {
-		// ignoring pull request against unconfigured project (could be just regular sources?)
-		return nil
-	}
-
-	PRProcessor, err := AllocatePRProcessor(pr, configs)
-	if err != nil {
-		log.Error(err)
-		return err
-	}
-	defer PRProcessor.git.Close()
-
-	return PRProcessor.Process(pr)
-}
-
-func (w *RequestProcessor) ProcessFunc(request *common.Request) error {
+func ProcesPullRequest(req *common.PullRequestWebhookEvent, configs []*common.AutogitConfig) error {
 	defer func() {
 		if r := recover(); r != nil {
 			common.LogInfo("panic cought --- recovered")
@@ -541,28 +455,36 @@ func (w *RequestProcessor) ProcessFunc(request *common.Request) error {
 		}
 	}()
 
-	var pr *models.PullRequest
-	var err error
-	if req, ok := request.Data.(*common.PullRequestWebhookEvent); ok {
-		pr, err = Gitea.GetPullRequest(req.Pull_Request.Base.Repo.Owner.Username, req.Pull_Request.Base.Repo.Name, req.Pull_Request.Number)
-		if err != nil {
-			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 {
-		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))
-			return err
-		}
-	} else {
+	if len(configs) < 1 {
+		// ignoring pull request against unconfigured project (could be just regular sources?)
+		return nil
+	}
+
+	pr, err := AllocatePRProcessor(req, configs)
+	if err != nil {
+		log.Error(err)
+		return err
+	}
+	defer pr.git.Close()
+
+	switch req.Action {
+	case "opened", "reopened", "synchronized", "edited", "closed", "reviewed":
+		return pr.Process(req)
+	}
+
+	common.LogError("Unhandled pull request action:", req.Action)
+	return nil
+}
+
+func (w *RequestProcessor) ProcessFunc(request *common.Request) error {
+	req, ok := request.Data.(*common.PullRequestWebhookEvent)
+	if !ok {
 		common.LogError("*** Invalid data format for PR processing.")
 		return fmt.Errorf("*** Invalid data format for PR processing.")
 	}
 
-	configs, ok := w.configuredRepos[pr.Base.Repo.Owner.UserName]
-	if !ok {
-		common.LogError("*** Cannot find config for org:", pr.Base.Repo.Owner.UserName)
-	}
-	return ProcesPullRequest(pr, configs)
+	org := req.Repository.Owner.Username
+	configs := w.configuredRepos[org]
+	return ProcesPullRequest(req, configs)
+
 }

workflow-pr/repo_check.go

@@ -55,7 +55,44 @@ func (s *DefaultStateChecker) ProcessPR(pr *models.PullRequest, config *common.A
 	return ProcesPullRequest(&event, common.AutogitConfigs{config})
 }
 
-func PrjGitSubmoduleCheck(config *common.AutogitConfig, git common.Git, repo string, submodules map[string]string) (prsToProcess []*interfaces.PRToProcess, err error) {
+func (s *DefaultStateChecker) VerifyProjectState(config *common.AutogitConfig) ([]*interfaces.PRToProcess, error) {
+	defer func() {
+		if r := recover(); r != nil {
+			common.LogError("panic caught")
+			if err, ok := r.(error); !ok {
+				common.LogError(err)
+			}
+			common.LogError(string(debug.Stack()))
+		}
+	}()
+
+	prsToProcess := []*interfaces.PRToProcess{}
+
+	prjGitOrg, prjGitRepo, prjGitBranch := config.GetPrjGit()
+	common.LogInfo("  checking", prjGitOrg+"/"+prjGitRepo+"#"+prjGitBranch)
+
+	git, err := GitHandler.CreateGitHandler(config.Organization)
+	common.LogDebug("Git Path:", git.GetPath())
+	if err != nil {
+		return nil, fmt.Errorf("Cannot create git handler: %w", err)
+	}
+	defer git.Close()
+
+	repo, err := Gitea.CreateRepositoryIfNotExist(git, prjGitOrg, prjGitRepo)
+	if err != nil {
+		return nil, fmt.Errorf("Error fetching or creating '%s/%s#%s' -- aborting verifyProjectState(). Err: %w", prjGitBranch, prjGitRepo, prjGitBranch, err)
+	}
+
+	_, err = git.GitClone(prjGitRepo, prjGitBranch, repo.SSHURL)
+	common.PanicOnError(err)
+
+	prsToProcess = append(prsToProcess, &interfaces.PRToProcess{
+		Org:    prjGitOrg,
+		Repo:   prjGitRepo,
+		Branch: prjGitBranch,
+	})
+	submodules, err := git.GitSubmoduleList(prjGitRepo, "HEAD")
+
 nextSubmodule:
 	for sub, commitID := range submodules {
 		common.LogDebug("  + checking", sub, commitID)
@@ -98,8 +135,8 @@ nextSubmodule:
 		}
 
 		// not found in past, check if we should advance the branch label ... pull the submodule
-		git.GitExecOrPanic(repo, "submodule", "update", "--init", "--filter", "blob:none", "--", sub)
-		subDir := path.Join(repo, sub)
+		git.GitExecOrPanic(prjGitRepo, "submodule", "update", "--init", "--filter", "blob:none", "--", sub)
+		subDir := path.Join(prjGitRepo, sub)
 		newCommits := common.SplitStringNoEmpty(git.GitExecWithOutputOrPanic(subDir, "rev-list", "^origin/"+branch, commitID), "\n")
 
 		if len(newCommits) >= 1 {
@@ -115,49 +152,8 @@ nextSubmodule:
 		}
 	}
 
-	return prsToProcess, nil
-}
-
-func (s *DefaultStateChecker) VerifyProjectState(config *common.AutogitConfig) ([]*interfaces.PRToProcess, error) {
-	defer func() {
-		if r := recover(); r != nil {
-			common.LogError("panic caught")
-			if err, ok := r.(error); !ok {
-				common.LogError(err)
-			}
-			common.LogError(string(debug.Stack()))
-		}
-	}()
-
-	prsToProcess := []*interfaces.PRToProcess{}
-
-	prjGitOrg, prjGitRepo, prjGitBranch := config.GetPrjGit()
-	common.LogInfo("  checking", prjGitOrg+"/"+prjGitRepo+"#"+prjGitBranch)
-
-	git, err := GitHandler.CreateGitHandler(config.Organization)
-	common.LogDebug("Git Path:", git.GetPath())
-	if err != nil {
-		return nil, fmt.Errorf("Cannot create git handler: %w", err)
-	}
-	defer git.Close()
-
-	repo, err := Gitea.CreateRepositoryIfNotExist(git, prjGitOrg, prjGitRepo)
-	if err != nil {
-		return nil, fmt.Errorf("Error fetching or creating '%s/%s#%s' -- aborting verifyProjectState(). Err: %w", prjGitBranch, prjGitRepo, prjGitBranch, err)
-	}
-
-	_, err = git.GitClone(prjGitRepo, prjGitBranch, repo.SSHURL)
-	common.PanicOnError(err)
-
-	prsToProcess = append(prsToProcess, &interfaces.PRToProcess{
-		Org:    prjGitOrg,
-		Repo:   prjGitRepo,
-		Branch: prjGitBranch,
-	})
-	submodules, err := git.GitSubmoduleList(prjGitRepo, "HEAD")
-
 	// forward any package-gits referred by the project git, but don't go back
-	return PrjGitSubmoduleCheck(config, git, prjGitRepo, submodules)
+	return prsToProcess, nil
 }
 
 func (s *DefaultStateChecker) CheckRepos() error {