Fix45 probes

go.mod

@@ -47,7 +47,7 @@ require (
 	github.com/stretchr/testify v1.10.0
 	github.com/tektoncd/cli v0.33.0
 	github.com/tektoncd/pipeline v0.68.0
-	github.com/xanzy/go-gitlab v0.104.1
+	github.com/xanzy/go-gitlab v0.110.0
 	golang.org/x/crypto v0.36.0
 	golang.org/x/oauth2 v0.25.0
 	golang.org/x/tools v0.28.0

go.sum

@@ -1939,6 +1939,8 @@ github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAh
 github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
 github.com/xanzy/go-gitlab v0.104.1 h1:g/liXIPJH0jsTwVuzTAUMiKdTf6Qup3u2XZq5Rp90Wc=
 github.com/xanzy/go-gitlab v0.104.1/go.mod h1:ETg8tcj4OhrB84UEgeE8dSuV/0h4BBL1uOV/qK0vlyI=
+github.com/xanzy/go-gitlab v0.110.0 h1:hsFIFp01v/0D0sdUXoZfRk6CROzZbHQplk6NzKSFKhc=
+github.com/xanzy/go-gitlab v0.110.0/go.mod h1:wKNKh3GkYDMOsGmnfuX+ITCmDuSDWFO0G+C4AygL9RY=
 github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
 github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=

pkg/clients/common/service_account.go

@@ -5,6 +5,7 @@ import (
 
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	. "github.com/onsi/ginkgo/v2"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -17,6 +18,7 @@ func (s *SuiteController) ServiceAccountPresent(saName, namespace string) wait.C
 	return func() (bool, error) {
 		_, err := s.GetServiceAccount(saName, namespace)
 		if err != nil {
+			GinkgoWriter.Printf("failed to get service account %s in namespace %s: %+v\n", saName, namespace, err)
 			return false, nil
 		}
 		return true, nil

pkg/clients/github/repositories.go

@@ -66,11 +66,15 @@ func (g *Github) CreateFile(repository, pathToFile, fileContent, branchName stri
 }
 
 func (g *Github) GetFile(repository, pathToFile, branchName string) (*github.RepositoryContent, error) {
+	return g.GetFileWithOrg(g.organization, repository, pathToFile, branchName)
+}
+
+func (g *Github) GetFileWithOrg(org, repository, pathToFile, branchName string) (*github.RepositoryContent, error) {
 	opts := &github.RepositoryContentGetOptions{}
 	if branchName != "" {
 		opts.Ref = fmt.Sprintf(HEADS, branchName)
 	}
-	file, _, _, err := g.client.Repositories.GetContents(context.Background(), g.organization, repository, pathToFile, opts)
+	file, _, _, err := g.client.Repositories.GetContents(context.Background(), org, repository, pathToFile, opts)
 	if err != nil {
 		return nil, fmt.Errorf("error when listing file contents: %v", err)
 	}
@@ -158,32 +162,33 @@ func (g *Github) DeleteRepositoryIfExists(name string) error {
 
 	_, resp, err := g.client.Repositories.Get(ctx, g.organization, name)
 	if err != nil {
-		if resp.StatusCode != 404 {
-			return fmt.Errorf("Error checking repository %s/%s: %v\n", g.organization, name, err)
-		}
-	} else {
-		_, deleteErr := g.client.Repositories.Delete(ctx, g.organization, name)
-		if deleteErr != nil {
-			return fmt.Errorf("Error deleting repository %s/%s: %v\n", g.organization, name, deleteErr)
+		if resp != nil && resp.StatusCode == 404 {
+			return nil
 		}
+		return fmt.Errorf("Error checking repository %s/%s: %v", g.organization, name, err)
+	}
+
+	_, deleteErr := g.client.Repositories.Delete(ctx, g.organization, name)
+	if deleteErr != nil {
+		return fmt.Errorf("Error deleting repository %s/%s: %v", g.organization, name, deleteErr)
 	}
 
 	return nil
 }
 
-func (g *Github) ForkRepository(sourceName, targetName string) (*github.Repository, error) {
+func (g *Github) ForkRepositoryWithOrgs(sourceOrgName, sourceName, targetOrgName, targetName string) (*github.Repository, error) {
 	var fork *github.Repository
 	var resp *github.Response
 	var repo *github.Repository
 
 	ctx := context.Background()
 
 	forkOptions := &github.RepositoryCreateForkOptions{
-		Organization: g.organization,
+		Organization: targetOrgName,
 	}
 
 	err1 := utils.WaitUntilWithInterval(func() (done bool, err error) {
-		fork, resp, err = g.client.Repositories.CreateFork(ctx, g.organization, sourceName, forkOptions)
+		fork, resp, err = g.client.Repositories.CreateFork(ctx, sourceOrgName, sourceName, forkOptions)
 		if err != nil {
 			if _, ok := err.(*github.AcceptedError); ok && resp.StatusCode == 202 {
 				// This meens forking is happening asynchronously
@@ -200,46 +205,61 @@ func (g *Github) ForkRepository(sourceName, targetName string) (*github.Reposito
 				fmt.Printf("Warning, got 500: %s", resp.Body)
 				return false, nil
 			}
-			return false, fmt.Errorf("Error forking %s/%s: %v", g.organization, sourceName, err)
+			return false, fmt.Errorf("Error forking %s/%s: %v", sourceOrgName, sourceName, err)
 		}
 		return true, nil
-	}, time.Second * 10, time.Minute * 30)
+	}, time.Second * 10, time.Minute * 5)
 	if err1 != nil {
-		return nil, fmt.Errorf("Failed waiting for fork %s/%s: %v", g.organization, sourceName, err1)
+		return nil, fmt.Errorf("Failed waiting for fork %s/%s: %v", sourceOrgName, sourceName, err1)
 	}
 
 	err2 := utils.WaitUntilWithInterval(func() (done bool, err error) {
 		// Using this to detect repo is created and populated with content
 		// https://stackoverflow.com/questions/33666838/determine-if-a-fork-is-ready
-		_, _, err = g.client.Repositories.ListCommits(ctx, g.organization, fork.GetName(), &github.CommitsListOptions{})
+		_, _, err = g.client.Repositories.ListCommits(ctx, targetOrgName, fork.GetName(), &github.CommitsListOptions{})
 		if err != nil {
 			return false, nil
 		}
 		return true, nil
 	}, time.Second * 10, time.Minute * 10)
 	if err2 != nil {
-		return nil, fmt.Errorf("Failed waiting for commits %s/%s: %v", g.organization, sourceName, err2)
+		return nil, fmt.Errorf("Failed waiting for commits %s/%s: %v", targetOrgName, fork.GetName(), err2)
 	}
 
 	editedRepo := &github.Repository{
 		Name: github.String(targetName),
 	}
 
 	err3 := utils.WaitUntilWithInterval(func() (done bool, err error) {
-		repo, resp, err = g.client.Repositories.Edit(ctx, g.organization, fork.GetName(), editedRepo)
+		repo, resp, err = g.client.Repositories.Edit(ctx, targetOrgName, fork.GetName(), editedRepo)
 		if err != nil {
 			if resp.StatusCode == 422 {
 				// This started to happen recently. Docs says 422 is "Validation failed, or the endpoint has been spammed." so we need to be patient.
 				// Error we are getting: "422 Validation Failed [{Resource:Repository Field:name Code:custom Message:name a repository operation is already in progress}]"
 				return false, nil
 			}
-			return false, fmt.Errorf("Error renaming %s/%s to %s: %v\n", g.organization, fork.GetName(), targetName, err)
+			return false, fmt.Errorf("Error renaming %s/%s to %s: %v", targetOrgName, fork.GetName(), targetName, err)
 		}
 		return true, nil
 	}, time.Second * 10, time.Minute * 10)
 	if err3 != nil {
-		return nil, fmt.Errorf("Failed waiting for renaming %s/%s: %v", g.organization, targetName, err3)
+		return nil, fmt.Errorf("Failed waiting for renaming %s/%s: %v", targetOrgName, targetName, err3)
 	}
 
 	return repo, nil
 }
+
+// Fork repository in our organization
+func (g *Github) ForkRepository(sourceName, targetName string) (*github.Repository, error) {
+	return g.ForkRepositoryWithOrgs(g.organization, sourceName, g.organization, targetName)
+}
+
+// For repozitory from our organization to another org
+func (g *Github) ForkRepositoryToOrg(sourceName, targetName, targetOrgName string) (*github.Repository, error) {
+	return g.ForkRepositoryWithOrgs(g.organization, sourceName, targetOrgName, targetName)
+}
+
+// Fork repository from another organization to our org
+func (g *Github) ForkRepositoryFromOrg(sourceName, targetName, sourceOrgName string) (*github.Repository, error) {
+	return g.ForkRepositoryWithOrgs(sourceOrgName, sourceName, g.organization, targetName)
+}