common: fix timeline cache race condition and update logic

The GetTimeline function previously used a strict timestamp comparison
(Created > LastCachedTime) to fetch new events. This caused the bot to
miss events occurring within the same second as the last update.

This change:
- Switches to ID-based deduplication to safely handle same-second events.
- Correctly updates existing timeline items if they are modified.
- Calculates the next 'Since' parameter using the maximum 'Updated'
  timestamp found in the current cache.

This fixes flakiness in integration tests (specifically test_006) where
maintainer rejections were occasionally ignored by the workflow-pr service.

common/gitea_utils.go

@@ -863,9 +863,10 @@ func (gitea *GiteaTransport) GetTimeline(org, repo string, idx int64) ([]*models
 	TimelineCache, IsCached := giteaTimelineCache[prID]
 	var LastCachedTime strfmt.DateTime
 	if IsCached {
-		l := len(TimelineCache.data)
-		if l > 0 {
-			LastCachedTime = TimelineCache.data[0].Updated
+		for _, d := range TimelineCache.data {
+			if time.Time(d.Updated).Compare(time.Time(LastCachedTime)) > 0 {
+				LastCachedTime = d.Updated
+			}
 		}
 
 		// cache data for 5 seconds
@@ -894,14 +895,20 @@ func (gitea *GiteaTransport) GetTimeline(org, repo string, idx int64) ([]*models
 		}
 
 		for _, d := range res.Payload {
-			if d != nil {
-				if time.Time(d.Created).Compare(time.Time(LastCachedTime)) > 0 {
-					// created after last check, so we append here
-					TimelineCache.data = append(TimelineCache.data, d)
-				} else {
-					// we need something updated in the timeline, maybe
+			if d == nil {
+				continue
+			}
+			found := false
+			for i := range TimelineCache.data {
+				if TimelineCache.data[i].ID == d.ID {
+					TimelineCache.data[i] = d
+					found = true
+					break
 				}
 			}
+			if !found {
+				TimelineCache.data = append(TimelineCache.data, d)
+			}
 		}
 
 		if resCount < 10 {

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/workflow_pr_review_test.py

@@ -139,7 +139,6 @@ index 0000000..e69de29
 
 
 @pytest.mark.t005
-# @pytest.mark.xfail(reason="TBD troubleshoot")
 def test_005_any_maintainer_approval_sufficient(maintainer_env, ownerA_client, ownerBB_client):
     """
     Test scenario:
@@ -201,7 +200,6 @@ index 0000000..e69de29
 
 
 @pytest.mark.t006
-@pytest.mark.xfail(reason="tbd flacky in ci")
 def test_006_maintainer_rejection_removes_other_requests(maintainer_env, ownerA_client, ownerBB_client):
     """
     Test scenario:

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/pr_processor.go

@@ -144,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
@@ -199,12 +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.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))
@@ -488,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