t: TC-MERGE-004

common/git_utils.go

@@ -396,17 +396,12 @@ func (e *GitHandlerImpl) GitExecQuietOrPanic(cwd string, params ...string) {
 }
 
 type ChanIO struct {
-	ch   chan byte
-	done chan struct{}
+	ch chan byte
 }
 
 func (c *ChanIO) Write(p []byte) (int, error) {
 	for _, b := range p {
-		select {
-		case c.ch <- b:
-		case <-c.done:
-			return 0, io.EOF
-		}
+		c.ch <- b
 	}
 	return len(p), nil
 }
@@ -415,32 +410,21 @@ func (c *ChanIO) Write(p []byte) (int, error) {
 func (c *ChanIO) Read(data []byte) (idx int, err error) {
 	var ok bool
 
-	select {
-	case data[idx], ok = <-c.ch:
+	data[idx], ok = <-c.ch
+	if !ok {
+		err = io.EOF
+		return
+	}
+	idx++
+
+	for len(c.ch) > 0 && idx < len(data) {
+		data[idx], ok = <-c.ch
 		if !ok {
 			err = io.EOF
 			return
 		}
-		idx++
-	case <-c.done:
-		err = io.EOF
-		return
-	}
 
-	for len(c.ch) > 0 && idx < len(data) {
-		select {
-		case data[idx], ok = <-c.ch:
-			if !ok {
-				err = io.EOF
-				return
-			}
-			idx++
-		case <-c.done:
-			err = io.EOF
-			return
-		default:
-			return
-		}
+		idx++
 	}
 
 	return
@@ -487,14 +471,7 @@ func parseGitMsg(data <-chan byte) (GitMsg, error) {
 	var size int
 
 	pos := 0
-	for {
-		c, ok := <-data
-		if !ok {
-			return GitMsg{}, io.EOF
-		}
-		if c == ' ' {
-			break
-		}
+	for c := <-data; c != ' '; c = <-data {
 		if (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') {
 			id[pos] = c
 			pos++
@@ -506,15 +483,7 @@ func parseGitMsg(data <-chan byte) (GitMsg, error) {
 
 	pos = 0
 	var c byte
-	for {
-		var ok bool
-		c, ok = <-data
-		if !ok {
-			return GitMsg{}, io.EOF
-		}
-		if c == ' ' || c == '\x00' {
-			break
-		}
+	for c = <-data; c != ' ' && c != '\x00'; c = <-data {
 		if c >= 'a' && c <= 'z' {
 			msgType[pos] = c
 			pos++
@@ -540,14 +509,7 @@ func parseGitMsg(data <-chan byte) (GitMsg, error) {
 		return GitMsg{}, fmt.Errorf("Invalid object type: '%s'", string(msgType))
 	}
 
-	for {
-		c, ok := <-data
-		if !ok {
-			return GitMsg{}, io.EOF
-		}
-		if c == '\x00' {
-			break
-		}
+	for c = <-data; c != '\000'; c = <-data {
 		if c >= '0' && c <= '9' {
 			size = size*10 + (int(c) - '0')
 		} else {
@@ -566,37 +528,18 @@ func parseGitCommitHdr(oldHdr [2]string, data <-chan byte) ([2]string, int, erro
 	hdr := make([]byte, 0, 60)
 	val := make([]byte, 0, 1000)
 
-	c, ok := <-data
-	if !ok {
-		return [2]string{}, 0, io.EOF
-	}
+	c := <-data
 	size := 1
 	if c != '\n' { // end of header marker
-		for {
-			if c == ' ' {
-				break
-			}
+		for ; c != ' '; c = <-data {
 			hdr = append(hdr, c)
 			size++
-			var ok bool
-			c, ok = <-data
-			if !ok {
-				return [2]string{}, size, io.EOF
-			}
 		}
 		if size == 1 { // continuation header here
 			hdr = []byte(oldHdr[0])
 			val = append([]byte(oldHdr[1]), '\n')
 		}
-		for {
-			var ok bool
-			c, ok = <-data
-			if !ok {
-				return [2]string{}, size, io.EOF
-			}
-			if c == '\n' {
-				break
-			}
+		for c := <-data; c != '\n'; c = <-data {
 			val = append(val, c)
 			size++
 		}
@@ -609,14 +552,7 @@ func parseGitCommitHdr(oldHdr [2]string, data <-chan byte) ([2]string, int, erro
 func parseGitCommitMsg(data <-chan byte, l int) (string, error) {
 	msg := make([]byte, 0, l)
 
-	for {
-		c, ok := <-data
-		if !ok {
-			return string(msg), io.EOF
-		}
-		if c == '\x00' {
-			break
-		}
+	for c := <-data; c != '\x00'; c = <-data {
 		msg = append(msg, c)
 		l--
 	}
@@ -642,7 +578,7 @@ func parseGitCommit(data <-chan byte) (GitCommit, error) {
 		var hdr [2]string
 		hdr, size, err := parseGitCommitHdr(hdr, data)
 		if err != nil {
-			return GitCommit{}, err
+			return GitCommit{}, nil
 		}
 		l -= size
 
@@ -663,28 +599,14 @@ func parseGitCommit(data <-chan byte) (GitCommit, error) {
 func parseTreeEntry(data <-chan byte, hashLen int) (GitTreeEntry, error) {
 	var e GitTreeEntry
 
-	for {
-		c, ok := <-data
-		if !ok {
-			return e, io.EOF
-		}
-		if c == ' ' {
-			break
-		}
+	for c := <-data; c != ' '; c = <-data {
 		e.mode = e.mode*8 + int(c-'0')
 		e.size++
 	}
 	e.size++
 
 	name := make([]byte, 0, 128)
-	for {
-		c, ok := <-data
-		if !ok {
-			return e, io.EOF
-		}
-		if c == '\x00' {
-			break
-		}
+	for c := <-data; c != '\x00'; c = <-data {
 		name = append(name, c)
 		e.size++
 	}
@@ -695,10 +617,7 @@ func parseTreeEntry(data <-chan byte, hashLen int) (GitTreeEntry, error) {
 
 	hash := make([]byte, 0, hashLen*2)
 	for range hashLen {
-		c, ok := <-data
-		if !ok {
-			return e, io.EOF
-		}
+		c := <-data
 		hash = append(hash, hexBinToAscii[((c&0xF0)>>4)], hexBinToAscii[c&0xF])
 	}
 	e.hash = string(hash)
@@ -719,16 +638,13 @@ func parseGitTree(data <-chan byte) (GitTree, error) {
 	for parsedLen < hdr.size {
 		entry, err := parseTreeEntry(data, len(hdr.hash)/2)
 		if err != nil {
-			return GitTree{}, err
+			return GitTree{}, nil
 		}
 
 		t.items = append(t.items, entry)
 		parsedLen += entry.size
 	}
-	c, ok := <-data // \0 read
-	if !ok {
-		return t, io.EOF
-	}
+	c := <-data // \0 read
 
 	if c != '\x00' {
 		return t, fmt.Errorf("Unexpected character during git tree data read")
@@ -749,16 +665,9 @@ func parseGitBlob(data <-chan byte) ([]byte, error) {
 
 	d := make([]byte, hdr.size)
 	for l := 0; l < hdr.size; l++ {
-		var ok bool
-		d[l], ok = <-data
-		if !ok {
-			return d, io.EOF
-		}
-	}
-	eob, ok := <-data
-	if !ok {
-		return d, io.EOF
+		d[l] = <-data
 	}
+	eob := <-data
 	if eob != '\x00' {
 		return d, fmt.Errorf("invalid byte read in parseGitBlob")
 	}
@@ -770,25 +679,16 @@ func (e *GitHandlerImpl) GitParseCommits(cwd string, commitIDs []string) (parsed
 	var done sync.Mutex
 
 	done.Lock()
-	done_signal := make(chan struct{})
-	var once sync.Once
-	close_done := func() {
-		once.Do(func() {
-			close(done_signal)
-		})
-	}
-
-	data_in, data_out := ChanIO{make(chan byte), done_signal}, ChanIO{make(chan byte), done_signal}
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 	parsedCommits = make([]GitCommit, 0, len(commitIDs))
 
 	go func() {
 		defer done.Unlock()
-		defer close_done()
 		defer close(data_out.ch)
 
 		for _, id := range commitIDs {
 			data_out.Write([]byte(id))
-			data_out.Write([]byte{0})
+			data_out.ch <- '\x00'
 			c, e := parseGitCommit(data_in.ch)
 			if e != nil {
 				err = fmt.Errorf("Error parsing git commit: %w", e)
@@ -815,14 +715,12 @@ func (e *GitHandlerImpl) GitParseCommits(cwd string, commitIDs []string) (parsed
 	LogDebug("command run:", cmd.Args)
 	if e := cmd.Run(); e != nil {
 		LogError(e)
-		close_done()
 		close(data_in.ch)
+		close(data_out.ch)
 		return nil, e
 	}
 
 	done.Lock()
-	close_done()
-	close(data_in.ch)
 	return
 }
 
@@ -831,21 +729,15 @@ func (e *GitHandlerImpl) GitCatFile(cwd, commitId, filename string) (data []byte
 	var done sync.Mutex
 
 	done.Lock()
-	done_signal := make(chan struct{})
-	var once sync.Once
-	close_done := func() {
-		once.Do(func() {
-			close(done_signal)
-		})
-	}
-	data_in, data_out := ChanIO{make(chan byte), done_signal}, ChanIO{make(chan byte), done_signal}
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 
 	go func() {
 		defer done.Unlock()
-		defer close_done()
 		defer close(data_out.ch)
+
 		data_out.Write([]byte(commitId))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
+
 		var c GitCommit
 		c, err = parseGitCommit(data_in.ch)
 		if err != nil {
@@ -853,9 +745,11 @@ func (e *GitHandlerImpl) GitCatFile(cwd, commitId, filename string) (data []byte
 			return
 		}
 		data_out.Write([]byte(c.Tree))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
+
 		var tree GitTree
 		tree, err = parseGitTree(data_in.ch)
+
 		if err != nil {
 			LogError("Error parsing git tree:", err)
 			return
@@ -865,7 +759,7 @@ func (e *GitHandlerImpl) GitCatFile(cwd, commitId, filename string) (data []byte
 			if te.isBlob() && te.name == filename {
 				LogInfo("blob", te.hash)
 				data_out.Write([]byte(te.hash))
-				data_out.Write([]byte{0})
+				data_out.ch <- '\x00'
 				data, err = parseGitBlob(data_in.ch)
 				return
 			}
@@ -890,13 +784,11 @@ func (e *GitHandlerImpl) GitCatFile(cwd, commitId, filename string) (data []byte
 	LogDebug("command run:", cmd.Args)
 	if e := cmd.Run(); e != nil {
 		LogError(e)
-		close_done()
 		close(data_in.ch)
+		close(data_out.ch)
 		return nil, e
 	}
 	done.Lock()
-	close_done()
-	close(data_in.ch)
 	return
 }
 
@@ -906,24 +798,16 @@ func (e *GitHandlerImpl) GitDirectoryList(gitPath, commitId string) (directoryLi
 	directoryList = make(map[string]string)
 
 	done.Lock()
-	done_signal := make(chan struct{})
-	var once sync.Once
-	close_done := func() {
-		once.Do(func() {
-			close(done_signal)
-		})
-	}
-	data_in, data_out := ChanIO{make(chan byte), done_signal}, ChanIO{make(chan byte), done_signal}
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 
 	LogDebug("Getting directory for:", commitId)
 
 	go func() {
 		defer done.Unlock()
-		defer close_done()
 		defer close(data_out.ch)
 
 		data_out.Write([]byte(commitId))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
 		var c GitCommit
 		c, err = parseGitCommit(data_in.ch)
 		if err != nil {
@@ -939,7 +823,7 @@ func (e *GitHandlerImpl) GitDirectoryList(gitPath, commitId string) (directoryLi
 				delete(trees, p)
 
 				data_out.Write([]byte(tree))
-				data_out.Write([]byte{0})
+				data_out.ch <- '\x00'
 				var tree GitTree
 				tree, err = parseGitTree(data_in.ch)
 
@@ -973,14 +857,12 @@ func (e *GitHandlerImpl) GitDirectoryList(gitPath, commitId string) (directoryLi
 	LogDebug("command run:", cmd.Args)
 	if e := cmd.Run(); e != nil {
 		LogError(e)
-		close_done()
 		close(data_in.ch)
+		close(data_out.ch)
 		return directoryList, e
 	}
 
 	done.Lock()
-	close_done()
-	close(data_in.ch)
 	return directoryList, err
 }
 
@@ -990,14 +872,7 @@ func (e *GitHandlerImpl) GitDirectoryContentList(gitPath, commitId string) (dire
 	directoryList = make(map[string]string)
 
 	done.Lock()
-	done_signal := make(chan struct{})
-	var once sync.Once
-	close_done := func() {
-		once.Do(func() {
-			close(done_signal)
-		})
-	}
-	data_in, data_out := ChanIO{make(chan byte), done_signal}, ChanIO{make(chan byte), done_signal}
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 
 	LogDebug("Getting directory content for:", commitId)
 
@@ -1006,7 +881,7 @@ func (e *GitHandlerImpl) GitDirectoryContentList(gitPath, commitId string) (dire
 		defer close(data_out.ch)
 
 		data_out.Write([]byte(commitId))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
 		var c GitCommit
 		c, err = parseGitCommit(data_in.ch)
 		if err != nil {
@@ -1022,7 +897,7 @@ func (e *GitHandlerImpl) GitDirectoryContentList(gitPath, commitId string) (dire
 				delete(trees, p)
 
 				data_out.Write([]byte(tree))
-				data_out.Write([]byte{0})
+				data_out.ch <- '\x00'
 				var tree GitTree
 				tree, err = parseGitTree(data_in.ch)
 
@@ -1058,14 +933,12 @@ func (e *GitHandlerImpl) GitDirectoryContentList(gitPath, commitId string) (dire
 	LogDebug("command run:", cmd.Args)
 	if e := cmd.Run(); e != nil {
 		LogError(e)
-		close_done()
 		close(data_in.ch)
+		close(data_out.ch)
 		return directoryList, e
 	}
 
 	done.Lock()
-	close_done()
-	close(data_in.ch)
 	return directoryList, err
 }
 
@@ -1075,24 +948,16 @@ func (e *GitHandlerImpl) GitSubmoduleList(gitPath, commitId string) (submoduleLi
 	submoduleList = make(map[string]string)
 
 	done.Lock()
-	done_signal := make(chan struct{})
-	var once sync.Once
-	close_done := func() {
-		once.Do(func() {
-			close(done_signal)
-		})
-	}
-	data_in, data_out := ChanIO{make(chan byte), done_signal}, ChanIO{make(chan byte), done_signal}
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 
 	LogDebug("Getting submodules for:", commitId)
 
 	go func() {
 		defer done.Unlock()
-		defer close_done()
 		defer close(data_out.ch)
 
 		data_out.Write([]byte(commitId))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
 		var c GitCommit
 		c, err = parseGitCommit(data_in.ch)
 		if err != nil {
@@ -1108,7 +973,7 @@ func (e *GitHandlerImpl) GitSubmoduleList(gitPath, commitId string) (submoduleLi
 				delete(trees, p)
 
 				data_out.Write([]byte(tree))
-				data_out.Write([]byte{0})
+				data_out.ch <- '\x00'
 				var tree GitTree
 				tree, err = parseGitTree(data_in.ch)
 
@@ -1145,26 +1010,17 @@ func (e *GitHandlerImpl) GitSubmoduleList(gitPath, commitId string) (submoduleLi
 	LogDebug("command run:", cmd.Args)
 	if e := cmd.Run(); e != nil {
 		LogError(e)
-		close_done()
 		close(data_in.ch)
+		close(data_out.ch)
 		return submoduleList, e
 	}
 
 	done.Lock()
-	close_done()
-	close(data_in.ch)
 	return submoduleList, err
 }
 
 func (e *GitHandlerImpl) GitSubmoduleCommitId(cwd, packageName, commitId string) (subCommitId string, valid bool) {
-	done_signal := make(chan struct{})
-	var once sync.Once
-	close_done := func() {
-		once.Do(func() {
-			close(done_signal)
-		})
-	}
-	data_in, data_out := ChanIO{make(chan byte), done_signal}, ChanIO{make(chan byte), done_signal}
+	data_in, data_out := ChanIO{make(chan byte)}, ChanIO{make(chan byte)}
 	var wg sync.WaitGroup
 
 	wg.Add(1)
@@ -1180,18 +1036,17 @@ func (e *GitHandlerImpl) GitSubmoduleCommitId(cwd, packageName, commitId string)
 		}()
 
 		defer wg.Done()
-		defer close_done()
 		defer close(data_out.ch)
 
 		data_out.Write([]byte(commitId))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
 		c, err := parseGitCommit(data_in.ch)
 		if err != nil {
 			LogError("Error parsing git commit:", err)
 			panic(err)
 		}
 		data_out.Write([]byte(c.Tree))
-		data_out.Write([]byte{0})
+		data_out.ch <- '\x00'
 		tree, err := parseGitTree(data_in.ch)
 
 		if err != nil {
@@ -1223,14 +1078,12 @@ func (e *GitHandlerImpl) GitSubmoduleCommitId(cwd, packageName, commitId string)
 	LogDebug("command run:", cmd.Args)
 	if e := cmd.Run(); e != nil {
 		LogError(e)
-		close_done()
 		close(data_in.ch)
+		close(data_out.ch)
 		return subCommitId, false
 	}
 
 	wg.Wait()
-	close_done()
-	close(data_in.ch)
 	return subCommitId, len(subCommitId) > 0
 }
 

common/git_utils_test.go

@@ -28,7 +28,6 @@ import (
 	"slices"
 	"strings"
 	"testing"
-	"time"
 )
 
 func TestGitClone(t *testing.T) {
@@ -718,44 +717,3 @@ func TestGitDirectoryListRepro(t *testing.T) {
 		t.Errorf("Expected 'subdir' in directory list, got %v", dirs)
 	}
 }
-
-func TestGitDeadlockFix(t *testing.T) {
-	gitDir := t.TempDir()
-	testDir, _ := os.Getwd()
-
-	cmd := exec.Command("/usr/bin/bash", path.Join(testDir, "tsetup.sh"))
-	cmd.Dir = gitDir
-	_, err := cmd.CombinedOutput()
-
-	gh, err := AllocateGitWorkTree(gitDir, "Test", "test@example.com")
-	if err != nil {
-		t.Fatal(err)
-	}
-	h, err := gh.ReadExistingPath(".")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer h.Close()
-
-	// Use a blob ID to trigger error in GitParseCommits
-	// This ensures that the function returns error immediately and doesn't deadlock
-	blobId := "81aba862107f1e2f5312e165453955485f424612f313d6c2fb1b31fef9f82a14"
-
-	done := make(chan error)
-	go func() {
-		_, err := h.GitParseCommits("", []string{blobId})
-		done <- err
-	}()
-
-	select {
-	case err := <-done:
-		if err == nil {
-			t.Error("Expected error from GitParseCommits with blob ID, got nil")
-		} else {
-			// This is expected
-			t.Logf("Got expected error: %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("GitParseCommits deadlocked! Fix is NOT working.")
-	}
-}

common/utils.go

@@ -44,42 +44,6 @@ type NewRepos struct {
 const maintainership_line = "MAINTAINER"
 
 var true_lines []string = []string{"1", "TRUE", "YES", "OK", "T"}
-var InvalidUrlError error = errors.New("PrjGit or PackageGit URLs cannot be empty.")
-var AbsoluteUrlError error = errors.New("PrjGit or PackageGit URLs cannot be relative.")
-var HostsNotEqualError error = errors.New("PrjGit or PackageGit are not the same hosts.")
-var AbsoluteUrlWithQuery error = errors.New("PrjGit or PackageGit with query parameter. Unsupported.")
-var InvalidPath error = errors.New("PrjGit or PackageGit path has unsupported format.")
-
-
-func RelativeRepositoryPath(prjgit_org, packagegit string) (string, error) {
-	if len(packagegit) == 0 {
-		return "", InvalidUrlError
-	}
-
-	pkggiturl, err := url.Parse(packagegit)
-	if err != nil {
-		return "", err
-	}
-	if !pkggiturl.IsAbs() {
-		return "", AbsoluteUrlError
-	}
-	if len(pkggiturl.RawQuery) != 0 {
-		return "", AbsoluteUrlWithQuery
-	}
-
-	pkggitpath := SplitStringNoEmpty(pkggiturl.Path, "/")
-
-	if len(pkggitpath) != 2 {
-		return "", InvalidPath
-	}
-
-	pkggitpath[1] = strings.TrimSuffix(pkggitpath[1], ".git")
-	if prjgit_org == pkggitpath[0] {
-		return "../" + pkggitpath[1], nil
-	}
-
-	return "../../" + pkggitpath[0] + "/" + pkggitpath[1], nil
-}
 
 func HasSpace(s string) bool {
 	return strings.IndexFunc(s, unicode.IsSpace) >= 0

common/utils_test.go

@@ -8,82 +8,6 @@ import (
 	"src.opensuse.org/autogits/common"
 )
 
-func TestRelativeRepositoryPath(t *testing.T) {
-	tests := []struct {
-		name         string
-		prjorg, repo string
-
-		hasError bool
-		relative string
-	}{
-		{
-			name:     "Empty packagegit",
-			prjorg:   "org1",
-			repo:     "",
-			hasError: true,
-		},
-		{
-			name:     "Invalid URL",
-			prjorg:   "org1",
-			repo:     ":",
-			hasError: true,
-		},
-		{
-			name:     "Relative packagegit",
-			prjorg:   "org1",
-			repo:     "/path/to/repo",
-			hasError: true,
-		},
-		{
-			name:     "Packagegit with query",
-			prjorg:   "org1",
-			repo:     "https://host/org1/repo?query=1",
-			hasError: true,
-		},
-		{
-			name:     "Invalid path (too short)",
-			prjorg:   "org1",
-			repo:     "https://host/repo",
-			hasError: true,
-		},
-		{
-			name:     "Invalid path (too long)",
-			prjorg:   "org1",
-			repo:     "https://host/org/repo/extra",
-			hasError: true,
-		},
-		{
-			name:     "Same org",
-			prjorg:   "org1",
-			repo:     "https://host/org1/repo.git",
-			relative: "../repo",
-		},
-		{
-			name:     "Different org",
-			prjorg:   "org1",
-			repo:     "https://host/org2/repo.git",
-			relative: "../../org2/repo",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			r, err := common.RelativeRepositoryPath(test.prjorg, test.repo)
-
-			if err != nil && !test.hasError {
-				t.Error("Expected no error but have one", err)
-			}
-			if err == nil && test.hasError {
-				t.Error("Expected an error but had none. Returned:", r)
-			}
-
-			if err == nil && test.relative != r {
-				t.Error("Expected", test.relative, "but have", r)
-			}
-		})
-	}
-}
-
 func TestGitUrlParse(t *testing.T) {
 	tests := []struct {
 		name     string

integration/tests/conftest.py

@@ -61,6 +61,12 @@ BRANCH_CONFIG_CUSTOM = {
             "Reviewers": ["+usera", "+userb", "-autogits_obs_staging_bot"]
         }
     },
+    "manual-multipkg-merge": {
+        "workflow.config": {
+            "ManualMergeOnly": True,
+            "Reviewers": ["+usera", "+ownerB", "-autogits_obs_staging_bot"]
+        }
+    },
     "label-test": {
         "workflow.config": {
             "ManualMergeProject": True,
@@ -274,6 +280,10 @@ def staging_main_env(gitea_env):
 def manual_merge_env(gitea_env):
     return gitea_env, "myproducts/mySLFO", "manual-merge"
 
+@pytest.fixture(scope="session")
+def manual_multipkg_merge_env(gitea_env):
+    return gitea_env, "myproducts/mySLFO", "manual-multipkg-merge"
+
 @pytest.fixture(scope="session")
 def maintainer_env(gitea_env):
     return gitea_env, "myproducts/mySLFO", "maintainer-merge"
@@ -327,5 +337,6 @@ def test_user_client(gitea_env):
     username = f"test-user-{int(time.time())}"
     gitea_env.create_user(username, "password123", f"{username}@example.com")
     gitea_env.add_collaborator("mypool", "pkgA", username, "write")
+    gitea_env.add_collaborator("mypool", "pkgB", username, "write")
     gitea_env.add_collaborator("myproducts", "mySLFO", username, "write")
     return GiteaAPIClient(base_url=gitea_env.base_url, token=gitea_env.headers["Authorization"].split(" ")[1], sudo=username)

integration/tests/workflow_pr_merge_test.py

@@ -65,7 +65,7 @@ index 0000000..e69de29
     print("Waiting for all expected review requests and approving them...")
     # Expected reviewers based on manual-merge branch config and pkgA maintainership
     expected_reviewers = {"usera", "userb", "ownerA", "ownerX", "ownerY"}
-    
+
     # ManualMergeOnly still requires regular reviews to be satisfied.
     # We poll until all expected reviewers are requested, then approve them.
     all_requested = False
@@ -73,7 +73,7 @@ index 0000000..e69de29
         # Trigger approvals for whatever is already requested
         gitea_env.approve_requested_reviews("mypool/pkgA", package_pr_number)
         gitea_env.approve_requested_reviews("myproducts/mySLFO", project_pr_number)
-        
+
         # Explicitly handle staging bot if it is requested or pending
         prj_reviews = gitea_env.list_reviews("myproducts/mySLFO", project_pr_number)
         if any(r["user"]["login"] == "autogits_obs_staging_bot" and r["state"] in ["REQUEST_REVIEW", "PENDING"] for r in prj_reviews):
@@ -83,7 +83,7 @@ index 0000000..e69de29
         # Check if all expected reviewers have at least one review record (any state)
         pkg_reviews = gitea_env.list_reviews("mypool/pkgA", package_pr_number)
         current_reviewers = {r["user"]["login"] for r in pkg_reviews}
-        
+
         if expected_reviewers.issubset(current_reviewers):
             # Also ensure they are all approved (not just requested)
             approved_reviewers = {r["user"]["login"] for r in pkg_reviews if r["state"] == "APPROVED"}
@@ -94,13 +94,13 @@ index 0000000..e69de29
                     all_requested = True
                     print(f"All expected reviewers {expected_reviewers} and staging bot have approved.")
                     break
-        
+
         pkg_details = gitea_env.get_pr_details("mypool/pkgA", package_pr_number)
         prj_details = gitea_env.get_pr_details("myproducts/mySLFO", project_pr_number)
-        
+
         assert not pkg_details.get("merged"), "Package PR merged prematurely (ManualMergeOnly ignored?)"
         assert not prj_details.get("merged"), "Project PR merged prematurely (ManualMergeOnly ignored?)"
-        
+
         time.sleep(2)
 
     assert all_requested, f"Timed out waiting for all expected reviewers {expected_reviewers} to approve. Current: {current_reviewers}"
@@ -114,25 +114,25 @@ index 0000000..e69de29
     print("Polling for PR merge status...")
     package_merged = False
     project_merged = False
-    
+
     for i in range(20): # Poll for up to 20 seconds
         if not package_merged:
             pkg_details = gitea_env.get_pr_details("mypool/pkgA", package_pr_number)
             if pkg_details.get("merged"):
                 package_merged = True
                 print(f"Package PR mypool/pkgA#{package_pr_number} merged.")
-        
+
         if not project_merged:
             prj_details = gitea_env.get_pr_details("myproducts/mySLFO", project_pr_number)
             if prj_details.get("merged"):
                 project_merged = True
                 print(f"Project PR myproducts/mySLFO#{project_pr_number} merged.")
-        
+
         if package_merged and project_merged:
             break
-            
+
         time.sleep(1)
-            
+
     assert package_merged, f"Package PR mypool/pkgA#{package_pr_number} was not merged after 'merge ok'."
     assert project_merged, f"Project PR myproducts/mySLFO#{project_pr_number} was not merged after 'merge ok'."
     print("Both PRs merged successfully after 'merge ok'.")
@@ -167,7 +167,7 @@ index 0000000..e69de29
     print("Waiting for all expected review requests and approving them...")
     # Expected reviewers based on manual-merge branch config and pkgA maintainership
     expected_reviewers = {"usera", "userb", "ownerA", "ownerX", "ownerY"}
-    
+
     # ManualMergeOnly still requires regular reviews to be satisfied.
     # We poll until all expected reviewers are requested, then approve them.
     all_requested = False
@@ -175,7 +175,7 @@ index 0000000..e69de29
         # Trigger approvals for whatever is already requested
         gitea_env.approve_requested_reviews("mypool/pkgA", package_pr_number)
         gitea_env.approve_requested_reviews("myproducts/mySLFO", project_pr_number)
-        
+
         # Explicitly handle staging bot if it is requested or pending
         prj_reviews = gitea_env.list_reviews("myproducts/mySLFO", project_pr_number)
         if any(r["user"]["login"] == "autogits_obs_staging_bot" and r["state"] in ["REQUEST_REVIEW", "PENDING"] for r in prj_reviews):
@@ -185,7 +185,7 @@ index 0000000..e69de29
         # Check if all expected reviewers have at least one review record (any state)
         pkg_reviews = gitea_env.list_reviews("mypool/pkgA", package_pr_number)
         current_reviewers = {r["user"]["login"] for r in pkg_reviews}
-        
+
         if expected_reviewers.issubset(current_reviewers):
             # Also ensure they are all approved (not just requested)
             approved_reviewers = {r["user"]["login"] for r in pkg_reviews if r["state"] == "APPROVED"}
@@ -196,13 +196,13 @@ index 0000000..e69de29
                     all_requested = True
                     print(f"All expected reviewers {expected_reviewers} and staging bot have approved.")
                     break
-        
+
         pkg_details = gitea_env.get_pr_details("mypool/pkgA", package_pr_number)
         prj_details = gitea_env.get_pr_details("myproducts/mySLFO", project_pr_number)
-        
+
         assert not pkg_details.get("merged"), "Package PR merged prematurely (ManualMergeOnly ignored?)"
         assert not prj_details.get("merged"), "Project PR merged prematurely (ManualMergeOnly ignored?)"
-        
+
         time.sleep(2)
 
     assert all_requested, f"Timed out waiting for all expected reviewers {expected_reviewers} to approve. Current: {current_reviewers}"
@@ -216,29 +216,157 @@ index 0000000..e69de29
     print("Polling for PR merge status...")
     package_merged = False
     project_merged = False
-    
+
     for i in range(20): # Poll for up to 20 seconds
         if not package_merged:
             pkg_details = gitea_env.get_pr_details("mypool/pkgA", package_pr_number)
             if pkg_details.get("merged"):
                 package_merged = True
                 print(f"Package PR mypool/pkgA#{package_pr_number} merged.")
-        
+
         if not project_merged:
             prj_details = gitea_env.get_pr_details("myproducts/mySLFO", project_pr_number)
             if prj_details.get("merged"):
                 project_merged = True
                 print(f"Project PR myproducts/mySLFO#{project_pr_number} merged.")
-        
+
         if package_merged and project_merged:
             break
-            
+
         time.sleep(1)
-            
+
     assert not package_merged, f"Package PR mypool/pkgA#{package_pr_number} was merged after 'merge ok'."
     assert not project_merged, f"Project PR myproducts/mySLFO#{project_pr_number} was merged after 'merge ok'."
     print("Both PRs merged not after 'merge ok'.")
 
+@pytest.mark.t004
+def test_004_multiple_packages_manual_merge(manual_multipkg_merge_env, test_user_client, usera_client, ownerB_client, staging_bot_client):
+
+    """
+    Test scenario TC-MERGE-004:
+
+    1. Create a ProjectGit PR that references multiple PackageGit PRs with ManualMergeOnly set to true.
+    2. Ensure all mandatory reviews are completed on both project and package PRs.
+    3. Comment merge ok on each package PR from the account of a package maintainer.
+    4. Verify PR is merged only after merge ok is commented on all associated PackageGit PRs.
+    """
+    gitea_env, test_full_repo_name, merge_branch_name = manual_multipkg_merge_env
+
+    # 1. Create a package PR
+    diff = """diff --git a/manual_merge_test.txt b/manual_merge_test.txt
+new file mode 100644
+index 0000000..e69de29
+"""
+    print(f"--- Creating package PR in mypool/pkgA on branch {merge_branch_name} ---")
+    package_pr1 = test_user_client.create_gitea_pr("mypool/pkgA", diff, "Test Manual Merge Fixture (MultiPKG)", False, base_branch=merge_branch_name)
+    package_pr1_number = package_pr1["number"]
+    print(f"Created package PR mypool/pkgA#{package_pr1_number}")
+
+    print(f"--- Creating package PR in mypool/pkgB on branch {merge_branch_name} ---")
+    package_pr2 = test_user_client.create_gitea_pr("mypool/pkgB", diff, "Test Manual Merge Fixture (MultiPKG)", False, base_branch=merge_branch_name)
+    package_pr2_number = package_pr2["number"]
+    print(f"Created package PR mypool/pkgB#{package_pr2_number}")
+
+    project_pr_number = gitea_env.wait_for_project_pr("mypool/pkgA", package_pr1_number)
+    assert project_pr_number is not None, "Workflow bot did not create a project PR (pkgA)."
+    print(f"Found project PR: myproducts/mySLFO#{project_pr_number}")
+
+    project_pr_number = gitea_env.wait_for_project_pr("mypool/pkgB", package_pr2_number)
+    assert project_pr_number is not None, "Workflow bot did not create a project PR (pkgB)."
+    print(f"Found project PR: myproducts/mySLFO#{project_pr_number}")
+
+    # 3. Approve reviews and verify NOT merged
+    print("Waiting for all expected review requests and approving them...")
+    # Expected reviewers based on manual-merge branch config and pkgA maintainership
+    expected_reviewers = {"usera", "userb", "ownerA", "ownerX", "ownerY"}
+
+    # ManualMergeOnly still requires regular reviews to be satisfied.
+    # We poll until all expected reviewers are requested, then approve them.
+    all_requested = False
+    for _ in range(30):
+        # Trigger approvals for whatever is already requested
+        gitea_env.approve_requested_reviews("mypool/pkgA", package_pr1_number)
+        gitea_env.approve_requested_reviews("mypool/pkgB", package_pr2_number)
+        gitea_env.approve_requested_reviews("myproducts/mySLFO", project_pr_number)
+
+        # Explicitly handle staging bot if it is requested or pending
+        prj_reviews = gitea_env.list_reviews("myproducts/mySLFO", project_pr_number)
+        if any(r["user"]["login"] == "autogits_obs_staging_bot" and r["state"] in ["REQUEST_REVIEW", "PENDING"] for r in prj_reviews):
+            print("Staging bot has a pending/requested review. Approving...")
+            staging_bot_client.create_review("myproducts/mySLFO", project_pr_number, event="APPROVED", body="Staging bot approves")
+
+        # Check if all expected reviewers have at least one review record (any state)
+        pkg_reviews = gitea_env.list_reviews("mypool/pkgA", package_pr1_number)
+        current_reviewers = {r["user"]["login"] for r in pkg_reviews}
+
+        pkg_reviews = gitea_env.list_reviews("mypool/pkgB", package_pr2_number)
+        current_reviewers = {r["user"]["login"] for r in pkg_reviews}
+
+        if expected_reviewers.issubset(current_reviewers):
+            # Also ensure they are all approved (not just requested)
+            approved_reviewers = {r["user"]["login"] for r in pkg_reviews if r["state"] == "APPROVED"}
+            if expected_reviewers.issubset(approved_reviewers):
+                # And check project PR for bot approval
+                prj_approved = any(r["user"]["login"] == "autogits_obs_staging_bot" and r["state"] == "APPROVED" for r in prj_reviews)
+                if prj_approved:
+                    all_requested = True
+                    print(f"All expected reviewers {expected_reviewers} and staging bot have approved.")
+                    break
+
+        pkg1_details = gitea_env.get_pr_details("mypool/pkgA", package_pr1_number)
+        pkg2_details = gitea_env.get_pr_details("mypool/pkgB", package_pr2_number)
+        prj_details  = gitea_env.get_pr_details("myproducts/mySLFO", project_pr_number)
+
+        assert not pkg1_details.get("merged"), "Package 1 PR merged prematurely (ManualMergeOnly ignored?)"
+        assert not pkg2_details.get("merged"), "Package 2 PR merged prematurely (ManualMergeOnly ignored?)"
+        assert not prj_details.get("merged"), "Project PR merged prematurely (ManualMergeOnly ignored?)"
+
+        time.sleep(2)
+
+    assert all_requested, f"Timed out waiting for all expected reviewers {expected_reviewers} to approve. Current: {current_reviewers}"
+    print("All PRs have all required approvals but are not merged (as expected with ManualMergeOnly).")
+
+    # 4. Comment "merge ok" from a requested reviewer (usera)
+    print("Commenting 'merge ok' on package PR as user usera ...")
+    usera_client.create_issue_comment("mypool/pkgA", package_pr1_number, "merge ok")
+    ownerB_client.create_issue_comment("mypool/pkgB", package_pr2_number, "merge ok")
+
+
+    # 5. Verify both PRs are merged
+    print("Polling for PR merge status...")
+    package1_merged = False
+    package2_merged = False
+    project_merged = False
+
+    for i in range(20): # Poll for up to 20 seconds
+        if not package1_merged:
+            pkg_details = gitea_env.get_pr_details("mypool/pkgA", package_pr1_number)
+            if pkg_details.get("merged"):
+                package1_merged = True
+                print(f"Package PR mypool/pkgA#{package_pr1_number} merged.")
+
+        if not package2_merged:
+            pkg_details = gitea_env.get_pr_details("mypool/pkgB", package_pr2_number)
+            if pkg_details.get("merged"):
+                package2_merged = True
+                print(f"Package PR mypool/pkgB#{package_pr2_number} merged.")
+
+        if not project_merged:
+            prj_details = gitea_env.get_pr_details("myproducts/mySLFO", project_pr_number)
+            if prj_details.get("merged"):
+                project_merged = True
+                print(f"Project PR myproducts/mySLFO#{project_pr_number} merged.")
+
+        if package1_merged and package2_merged and project_merged:
+            break
+
+        time.sleep(1)
+
+    assert not package1_merged, f"Package PR mypool/pkgA#{package_pr1_number} was merged after 'merge ok'."
+    assert not package2_merged, f"Package PR mypool/pkgB#{package_pr2_number} was merged after 'merge ok'."
+    assert not project_merged, f"Project PR myproducts/mySLFO#{project_pr_number} was merged after 'merge ok'."
+    print("Both PRs merged not after 'merge ok'.")
+
 @pytest.mark.t008
 def test_008_merge_mode_ff_only_success(merge_ff_env, test_user_client):
     """
@@ -253,7 +381,7 @@ index 0000000..e69de29
 """
     package_pr = test_user_client.create_gitea_pr("mypool/pkgA", diff, "Test FF Merge", False, base_branch=merge_branch_name)
     package_pr_number = package_pr["number"]
-    
+
     project_pr_number = gitea_env.wait_for_project_pr("mypool/pkgA", package_pr_number)
     assert project_pr_number is not None
 
@@ -281,7 +409,7 @@ index 0000000..e69de29
 """
     package_pr = ownerA_client.create_gitea_pr("mypool/pkgA", diff, "Test FF Merge Failure (Conflict)", False, base_branch=merge_branch_name)
     package_pr_number = package_pr["number"]
-    
+
     # 2. Wait for project PR to be created
     project_pr_number = gitea_env.wait_for_project_pr("mypool/pkgA", package_pr_number)
     assert project_pr_number is not None
@@ -294,24 +422,24 @@ index 0000000..e69de29
     gitea_env.approve_requested_reviews("myproducts/mySLFO", project_pr_number)
 
     print("Pushing another change to PR branch to trigger sync...")
-    gitea_env.modify_gitea_pr("mypool/pkgA", package_pr_number, 
+    gitea_env.modify_gitea_pr("mypool/pkgA", package_pr_number,
                              "diff --git a/sync_test.txt b/sync_test.txt\nnew file mode 100644\nindex 0000000..e69de29\n",
                              "Trigger Sync")
 
     # The bot should detect it's not FF and NOT merge, and re-request reviews because of the new commit
     print("Waiting for reviews to be re-requested and approving again...")
     time.sleep(10) # Wait for bot to process sync
-    
+
     # Approve again and verify it is NOT merged
     print("Approving again and verifying PR is NOT merged (because it's not FF)...")
     for i in range(15):
         gitea_env.approve_requested_reviews("mypool/pkgA", package_pr_number)
         gitea_env.approve_requested_reviews("myproducts/mySLFO", project_pr_number)
         time.sleep(1)
-        
+
     pkg_details = gitea_env.get_pr_details("mypool/pkgA", package_pr_number)
     assert not pkg_details.get("merged"), "Package PR merged despite NOT being FF-mergeable!"
-    
+
     print("FF-only failure (not merged after sync) verified.")
 
 @pytest.mark.t010
@@ -335,7 +463,7 @@ index 0000000..e69de29
 """
     package_pr = ownerA_client.create_gitea_pr("mypool/pkgA", diff, "Test Devel Merge (Conflict)", False, base_branch=merge_branch_name)
     package_pr_number = package_pr["number"]
-    
+
     # 2. Create a content conflict by committing the same file to the base branch
     gitea_env.create_file("mypool", "pkgA", filename, "Conflicting base content\n", branch=merge_branch_name)
 
@@ -377,10 +505,10 @@ index 0000000..e69de29
 """
     package_pr = ownerA_client.create_gitea_pr("mypool/pkgA", diff, "Test Replace Merge (Conflict)", False, base_branch=merge_branch_name)
     package_pr_number = package_pr["number"]
-    
+
     # Enable "Allow edits from maintainers"
     ownerA_client.update_gitea_pr_properties("mypool/pkgA", package_pr_number, allow_maintainer_edit=True)
-    
+
     # 2. Create a content conflict by committing the same file to the base branch
     gitea_env.create_file("mypool", "pkgA", filename, "Conflicting base content\n", branch=merge_branch_name)
 
@@ -400,7 +528,7 @@ index 0000000..e69de29
     # Verify that the project branch HEAD is a merge commit
     branch_info = gitea_env._request("GET", f"repos/myproducts/mySLFO/branches/{merge_branch_name}").json()
     new_head_sha = branch_info["commit"]["id"]
-    
+
     commit_details = gitea_env._request("GET", f"repos/myproducts/mySLFO/git/commits/{new_head_sha}").json()
     assert len(commit_details["parents"]) > 1, f"Project branch {merge_branch_name} HEAD should be a merge commit but has {len(commit_details['parents'])} parents"
 
@@ -429,7 +557,7 @@ index 0000000..e69de29
 """
     package_pr = ownerA_client.create_gitea_pr("mypool/pkgA", diff, "Test Devel FF Merge", False, base_branch=merge_branch_name)
     package_pr_number = package_pr["number"]
-    
+
     project_pr_number = gitea_env.wait_for_project_pr("mypool/pkgA", package_pr_number)
     assert project_pr_number is not None
 
@@ -444,7 +572,7 @@ index 0000000..e69de29
     branch_info = gitea_env._request("GET", f"repos/mypool/pkgA/branches/{merge_branch_name}").json()
     new_head_sha = branch_info["commit"]["id"]
     assert new_head_sha == pkg_head_sha, f"Package branch {merge_branch_name} HEAD should be {pkg_head_sha} but is {new_head_sha}"
-    
+
     commit_details = gitea_env._request("GET", f"repos/mypool/pkgA/git/commits/{new_head_sha}").json()
     assert len(commit_details["parents"]) == 1, f"Package branch {merge_branch_name} HEAD should have 1 parent but has {len(commit_details['parents'])}"
 
@@ -469,7 +597,7 @@ index 0000000..e69de29
 """
     package_pr = ownerA_client.create_gitea_pr("mypool/pkgA", diff, "Test Replace FF Merge", False, base_branch=merge_branch_name)
     package_pr_number = package_pr["number"]
-    
+
     project_pr_number = gitea_env.wait_for_project_pr("mypool/pkgA", package_pr_number)
     assert project_pr_number is not None
 
@@ -484,7 +612,7 @@ index 0000000..e69de29
     branch_info = gitea_env._request("GET", f"repos/mypool/pkgA/branches/{merge_branch_name}").json()
     new_head_sha = branch_info["commit"]["id"]
     assert new_head_sha == pkg_head_sha, f"Package branch {merge_branch_name} HEAD should be {pkg_head_sha} but is {new_head_sha}"
-    
+
     commit_details = gitea_env._request("GET", f"repos/mypool/pkgA/git/commits/{new_head_sha}").json()
     assert len(commit_details["parents"]) == 1, f"Package branch {merge_branch_name} HEAD should have 1 parent but has {len(commit_details['parents'])}"
-    
+

integration/workflow-pr/workflow-pr.json

@@ -7,6 +7,7 @@
     "myproducts/mySLFO#review-required",
     "myproducts/mySLFO#label-test",
     "myproducts/mySLFO#manual-merge",
+    "myproducts/mySLFO#manual-multipkg-merge",
     "myproducts/mySLFO#merge-ff",
     "myproducts/mySLFO#merge-replace",
     "myproducts/mySLFO#merge-devel"

workflow-direct/main.go

@@ -19,7 +19,6 @@ package main
  */
 
 import (
-	"bytes"
 	"flag"
 	"fmt"
 	"io/fs"
@@ -124,9 +123,7 @@ func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, co
 			common.LogError("   - ", action.Repository.Name, "repo is not sha256. Ignoring.")
 			return
 		}
-		relpath, err := common.RelativeRepositoryPath(gitOrg, action.Repository.Clone_Url)
-		common.PanicOnError(err)
-		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", relpath, action.Repository.Name))
+		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", action.Repository.Clone_Url, action.Repository.Name))
 		defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all", "-f")
 
 		branch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, action.Repository.Name), "branch", "--show-current"))
@@ -271,12 +268,6 @@ func verifyProjectState(git common.Git, org string, config *common.AutogitConfig
 	sub, err := git.GitSubmoduleList(gitPrj, "HEAD")
 	common.PanicOnError(err)
 
-	submodulesData, err := git.GitCatFile(gitPrj, "HEAD", ".gitmodules")
-	var submoduleEntries []common.Submodule
-	if err == nil {
-		submoduleEntries, _ = common.ParseSubmodulesFile(bytes.NewReader(submodulesData))
-	}
-
 	common.LogDebug("   * Getting package links")
 	var pkgLinks []*PackageRebaseLink
 	if f, err := fs.Stat(os.DirFS(path.Join(git.GetPath(), gitPrj)), common.PrjLinksFile); err == nil && (f.Mode()&fs.ModeType == 0) && f.Size() < 1000000 {
@@ -404,27 +395,8 @@ next_repo:
 		}
 		//		}
 
-		relpath, err := common.RelativeRepositoryPath(gitOrg, r.CloneURL)
-		common.PanicOnError(err)
-
 		for repo := range sub {
 			if repo == r.Name {
-				// verify we are using relative repository paths, and if not, adjust them
-				sidx := slices.IndexFunc(submoduleEntries, func(s common.Submodule) bool {
-					if path.Base(s.Path) == r.Name {
-						return true
-					}
-					return false
-				})
-				if sidx >= 0 && submoduleEntries[sidx].Url != relpath {
-					submoduleEntries[sidx].Url = relpath
-					f, err := os.OpenFile(path.Join(git.GetPath(), ".gitmodules"), os.O_CREATE|os.O_TRUNC, 0o6400)
-					common.PanicOnError(err)
-					defer f.Close()
-					common.PanicOnError(common.WriteSubmodules(submoduleEntries, f))
-					isGitUpdated = true
-				}
-
 				// not missing
 				continue next_repo
 			}
@@ -448,7 +420,7 @@ next_repo:
 		}
 
 		// add repository to git project
-		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", relpath, r.Name))
+		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", r.CloneURL, r.Name))
 
 		curBranch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, r.Name), "branch", "--show-current"))
 		if branch != curBranch {

workflow-pr/issue_processor.go

@@ -131,7 +131,6 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		common.LogDebug(" - Processing new repository src:", nr.Organization+"/"+nr.PackageName+"#"+nr.Branch)
 
 		targetRepo, err := Gitea.GetRepository(config.Organization, nr.PackageName)
-		common.LogDebug(" - Target repository:", config.Organization+"/"+nr.PackageName, "exists?", targetRepo != nil, "error?", err)
 		if err != nil {
 			return err
 		}
@@ -149,7 +148,6 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		// TODO, we need to filter by project config permissions of target project, not just assume bot here.
 		users := []string{CurrentUser.UserName}
 		prs := i.IssueTimeline.FindIssuePullRequestRererences(config.Organization, nr.PackageName, 0, users)
-		common.LogDebug(" - Existing PR references in timeline:", len(prs))
 		for _, t := range prs {
 			pr, err := Gitea.GetPullRequest(config.Organization, nr.PackageName, t.RefIssue.Index)
 			if err != nil {
@@ -173,9 +171,7 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		}
 
 		srcRepo, err := FindSourceRepository(nr.Organization, nr.Repository)
-		common.LogDebug(" - FindSourceRepository:", nr.Organization+"/"+nr.Repository, "err?", err)
 		if err != nil {
-			common.LogError(" - Skipping: cannot find source repository:", nr.Organization+"/"+nr.Repository, err)
 			continue
 		}
 
@@ -187,15 +183,12 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		if err != nil {
 			return err
 		}
-		// Clone the target using its default branch — the target branch may not exist yet
-		// and will be created by the push below.
-		remoteName, err := git.GitClone(nr.PackageName, targetRepo.DefaultBranch, targetRepo.SSHURL)
+		remoteName, err := git.GitClone(nr.PackageName, nr.Branch, targetRepo.SSHURL)
 		if err != nil {
 			return err
 		}
 
 		// Check that fork/parent repository relationship exists
-		common.LogDebug(" - Fork check: src.Parent=", srcRepo.Parent.Owner.UserName+"/"+srcRepo.Parent.Name, "target=", targetRepo.Owner.UserName+"/"+targetRepo.Name)
 		if srcRepo.Parent.Name != targetRepo.Name || srcRepo.Parent.Owner.UserName != targetRepo.Owner.UserName {
 			common.LogError("Source repository is not fork of the Target repository. Fork of:", srcRepo.Parent.Owner.UserName+"/"+srcRepo.Parent.Name)
 			continue
@@ -236,7 +229,6 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		if err == nil && strings.Contains(out, "refs/heads/"+srcBranch) {
 			isBranch = true
 		}
-		common.LogDebug(" - head:", head, "isBranch:", isBranch)
 
 		if !isBranch {
 			tempBranch := fmt.Sprintf("new_package_%d_%s", issue.Index, nr.PackageName)
@@ -262,7 +254,6 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		if len(br) == 0 {
 			br = targetRepo.DefaultBranch
 		}
-		common.LogDebug(" - Creating PR: head=", head, "base=", br, "title=", title)
 		pr, err, isNew := Gitea.CreatePullRequestIfNotExist(targetRepo, head, br, title, body)
 		if err != nil {
 			common.LogError(targetRepo.Name, head, i.TargetBranch, title, body)
@@ -294,7 +285,6 @@ func (i *IssueProcessor) ProcessIssue(configs common.AutogitConfigs) error {
 
 	//	out, _ := json.MarshalIndent(issue, "", "   ")
 	//	common.LogDebug(string(out))
-	common.LogInfo("Processing issue:", common.IssueToString(issue))
 
 	var err error
 	i.IssueTimeline, err = Gitea.GetTimeline(org, repo, idx)

workflow-pr/main.go

@@ -185,7 +185,6 @@ func main() {
 			common.RequestType_PRReviewAccepted: req,
 			common.RequestType_PRReviewRejected: req,
 			common.RequestType_PRComment:        req,
-			common.RequestType_Issue:            req,
 		},
 	}
 	listenDefs.Connection().RabbitURL, _ = url.Parse(*rabbitUrl)

workflow-pr/pr_processor.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
 	"path"
 	"runtime/debug"
 	"slices"
@@ -145,7 +144,6 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 		return err
 	}
 
-	PrjGitOrg, _, _ := prset.Config.GetPrjGit()
 	for _, pr := range prset.PRs {
 		if prset.IsPrjGitPR(pr.PR) {
 			continue
@@ -200,26 +198,7 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 			ref := fmt.Sprintf(common.PrPattern, org, repo, idx)
 			commitMsg := fmt.Sprintln("Add package", repo, "\n\nThis commit was autocreated by", GitAuthor, "\n\nreferencing PRs:\n", ref)
 
-			relpath, err := common.RelativeRepositoryPath(PrjGitOrg, pr.PR.Base.Repo.CloneURL)
-			if err != nil {
-				common.LogError("Cannot calculate relative path for repository", pr.PR.Base.Repo.CloneURL, err)
-				return err
-			}
-			// git submodule add refuses to proceed if the repo already exists
-			// locally (left by a prior GitClone). Two locations must be cleared:
-			//   1. the working tree dir
-			//   2. .git/modules/<repo> cached by git from a previous submodule init
-			staleWorkTree := path.Join(git.GetPath(), common.DefaultGitPrj, repo)
-			staleGitModules := path.Join(git.GetPath(), common.DefaultGitPrj, ".git", "modules", repo)
-			for _, staleDir := range []string{staleWorkTree, staleGitModules} {
-				if _, err := os.Stat(staleDir); err == nil {
-					common.LogDebug("Removing stale dir before submodule add:", staleDir)
-					if err := os.RemoveAll(staleDir); err != nil {
-						return err
-					}
-				}
-			}
-			git.GitExecOrPanic(common.DefaultGitPrj, "submodule", "add", "-b", pr.PR.Base.Name, relpath, repo)
+			git.GitExecOrPanic(common.DefaultGitPrj, "submodule", "add", "-b", pr.PR.Base.Name, pr.PR.Base.Repo.SSHURL, repo)
 
 			updateSubmoduleInPR(repo, prHead, git)
 			common.PanicOnError(git.GitExec(common.DefaultGitPrj, "commit", "-a", "-m", commitMsg))
@@ -503,11 +482,11 @@ func (pr *PRProcessor) Process(req *models.PullRequest) error {
 						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",
-						//						})
+//					} else {
+//						Gitea.AddComment(pr.PR, "Closing here because the associated Project PR has been closed.")
+//						Gitea.UpdatePullRequest(org, repo, idx, &models.EditPullRequestOption{
+//							State: "closed",
+//						})
 					}
 				}
 			}

workflow-pr/pr_processor_test.go

@@ -28,10 +28,8 @@ func TestPrjGitDescription(t *testing.T) {
 					Base: &models.PRBranchInfo{
 						Ref: "main",
 						Repo: &models.Repository{
-							Name:     "pkg-a",
-							Owner:    &models.User{UserName: "test-org"},
-							CloneURL: "http://example.com/test-org/pkg-a.git",
-							SSHURL:   "git@example.com:test-org/pkg-a.git",
+							Name:  "pkg-a",
+							Owner: &models.User{UserName: "test-org"},
 						},
 					},
 				},
@@ -204,10 +202,8 @@ func TestSetSubmodulesToMatchPRSet(t *testing.T) {
 					Base: &models.PRBranchInfo{
 						Ref: "main",
 						Repo: &models.Repository{
-							Name:     "pkg-a",
-							Owner:    &models.User{UserName: "test-org"},
-							CloneURL: "http://example.com/test-org/pkg-a.git",
-							SSHURL:   "git@example.com:test-org/pkg-a.git",
+							Name:  "pkg-a",
+							Owner: &models.User{UserName: "test-org"},
 						},
 					},
 					Head: &models.PRBranchInfo{
@@ -634,12 +630,7 @@ func TestCreatePRjGitPR_Integration(t *testing.T) {
 				PR: &models.PullRequest{
 					State: "open",
 					Base: &models.PRBranchInfo{
-						Repo: &models.Repository{
-							Name:     "pkg-a",
-							Owner:    &models.User{UserName: "test-org"},
-							CloneURL: "http://example.com/test-org/pkg-a.git",
-							SSHURL:   "git@example.com:test-org/pkg-a.git",
-						},
+						Repo: &models.Repository{Name: "pkg-a", Owner: &models.User{UserName: "test-org"}},
 					},
 					Head: &models.PRBranchInfo{Sha: "pkg-sha"},
 				},
@@ -662,23 +653,14 @@ func TestCreatePRjGitPR_Integration(t *testing.T) {
 			Base: &models.PRBranchInfo{
 				Name:   "main",
 				RepoID: 1,
-				Repo: &models.Repository{
-					Name:     "test-prj",
-					Owner:    &models.User{UserName: "test-org"},
-					CloneURL: "http://example.com/test-org/test-prj.git",
-					SSHURL:   "git@example.com:test-org/test-prj.git",
-				},
+				Repo:   &models.Repository{Name: "test-prj", Owner: &models.User{UserName: "test-org"}},
 			},
 			Head: &models.PRBranchInfo{
 				Sha: "prj-head-sha",
 			},
 		}
 
-		gitea.EXPECT().GetRepository(gomock.Any(), gomock.Any()).Return(&models.Repository{
-			Owner:    &models.User{UserName: "test-org"},
-			CloneURL: "http://example.com/test-org/test-prj.git",
-			SSHURL:   "git@example.com:test-org/test-prj.git",
-		}, nil).AnyTimes()
+		gitea.EXPECT().GetRepository(gomock.Any(), gomock.Any()).Return(&models.Repository{Owner: &models.User{UserName: "test-org"}}, nil).AnyTimes()
 		// CreatePullRequestIfNotExist returns isNew=true
 		gitea.EXPECT().CreatePullRequestIfNotExist(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(prjPR, nil, true).AnyTimes()
 		// Expect SetLabels to be called for new PR