feat: support PipelineRun running status reporting on Github with Kueue

this adds support running status of the PipelineRun when
PipelineRuns are managed by Kueue.

https://issues.redhat.com/browse/SRVKP-7738

Signed-off-by: Zaki Shaikh <[email protected]>

Author: zakisk

pkg/provider/bitbucketcloud/bitbucket.go

@@ -323,3 +323,7 @@ func (v *Provider) CreateToken(_ context.Context, _ []string, _ *info.Event) (st
 func (v *Provider) GetTemplate(commentType provider.CommentType) string {
 	return provider.GetMarkdownTemplate(commentType)
 }
+
+func (v *Provider) GetStatus(_ context.Context, _ *info.Event, _ string) (string, error) {
+	return "", nil
+}

pkg/provider/bitbucketdatacenter/bitbucketdatacenter.go

@@ -431,3 +431,7 @@ func (v *Provider) CreateToken(_ context.Context, _ []string, _ *info.Event) (st
 func (v *Provider) GetTemplate(commentType provider.CommentType) string {
 	return provider.GetMarkdownTemplate(commentType)
 }
+
+func (v *Provider) GetStatus(_ context.Context, _ *info.Event, _ string) (string, error) {
+	return "", nil
+}

pkg/provider/gitea/gitea.go

@@ -466,3 +466,7 @@ func (v *Provider) CreateToken(_ context.Context, _ []string, _ *info.Event) (st
 func (v *Provider) GetTemplate(commentType provider.CommentType) string {
 	return provider.GetHTMLTemplate(commentType)
 }
+
+func (v *Provider) GetStatus(_ context.Context, _ *info.Event, _ string) (string, error) {
+	return "", nil
+}

pkg/provider/github/github.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"net/url"
 	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -664,3 +665,25 @@ func (v *Provider) CreateComment(ctx context.Context, event *info.Event, commit,
 	})
 	return err
 }
+
+// GetStatus returns the status of PipelineRun from check-run API.
+// possible value from API response: queued, in_progress, completed, waiting, requested, pending.
+func (v *Provider) GetStatus(ctx context.Context, event *info.Event, statusID string) (string, error) {
+	if v.ghClient == nil {
+		return "", fmt.Errorf("no github client has been initialized")
+	}
+
+	checkRunID, err := strconv.ParseInt(statusID, 10, 64)
+	if err != nil {
+		return "", fmt.Errorf("invalid check-run ID: %w", err)
+	}
+	cr, _, err := v.ghClient.Checks.GetCheckRun(ctx, event.Organization, event.Repository, checkRunID)
+	if err != nil {
+		return "", err
+	}
+
+	// we have status terms we use across PaC and map those terms with git provider specific status terms returned by API
+	// response. here we only want to check that the status is queue or not. if it is queued and PipelineRun is running
+	// in cluster then we're supposed to update status to running via CreateStatus func.
+	return cr.GetStatus(), nil
+}

pkg/provider/gitlab/gitlab.go

@@ -540,3 +540,7 @@ func (v *Provider) isHeadCommitOfBranch(runevent *info.Event, branchName string)
 func (v *Provider) GetTemplate(commentType provider.CommentType) string {
 	return provider.GetHTMLTemplate(commentType)
 }
+
+func (v *Provider) GetStatus(_ context.Context, _ *info.Event, _ string) (string, error) {
+	return "", nil
+}

pkg/provider/interface.go

@@ -47,6 +47,7 @@ type Interface interface {
 	CheckPolicyAllowing(context.Context, *info.Event, []string) (bool, string)
 	GetTemplate(CommentType) string
 	CreateComment(ctx context.Context, event *info.Event, comment, updateMarker string) error
+	GetStatus(ctx context.Context, event *info.Event, statusID string) (string, error)
 }
 
 const DefaultProviderAPIUser = "git"

pkg/reconciler/reconciler.go

@@ -43,6 +43,8 @@ type Reconciler struct {
 	eventEmitter      *events.EventEmitter
 	globalRepo        *v1alpha1.Repository
 	secretNS          string
+	event             *info.Event
+	repo              *v1alpha1.Repository
 }
 
 var (
@@ -54,6 +56,51 @@ var (
 func (r *Reconciler) ReconcileKind(ctx context.Context, pr *tektonv1.PipelineRun) pkgreconciler.Event {
 	ctx = info.StoreNS(ctx, system.Namespace())
 	logger := logging.FromContext(ctx).With("namespace", pr.GetNamespace())
+	vcx, err := r.getProvider(ctx, pr, logger)
+	if err != nil {
+		return err
+	}
+	reason := ""
+	if len(pr.Status.GetConditions()) > 0 {
+		reason = pr.Status.Status.GetConditions()[0].GetReason()
+	}
+	if reason != "" && reason == string(tektonv1.PipelineRunReasonRunning) {
+		checkRunID := pr.GetAnnotations()[keys.CheckRunID]
+		status, err := vcx.GetStatus(ctx, r.event, checkRunID)
+		if err != nil {
+			return fmt.Errorf("failed to get status of PipelineRun %s: %w", pr.GetName(), err)
+		}
+
+		if status == "queued" {
+			consoleURL := r.run.Clients.ConsoleUI().DetailURL(pr)
+			mt := formatting.MessageTemplate{
+				PipelineRunName: pr.GetName(),
+				Namespace:       r.repo.GetNamespace(),
+				ConsoleName:     r.run.Clients.ConsoleUI().GetName(),
+				ConsoleURL:      consoleURL,
+				TknBinary:       settings.TknBinaryName,
+				TknBinaryURL:    settings.TknBinaryURL,
+			}
+
+			msg, err := mt.MakeTemplate(vcx.GetTemplate(provider.StartingPipelineType))
+			if err != nil {
+				return fmt.Errorf("cannot create message template: %w", err)
+			}
+			status := provider.StatusOpts{
+				Status:                  "in_progress",
+				Conclusion:              "pending",
+				Text:                    msg,
+				DetailsURL:              consoleURL,
+				PipelineRunName:         pr.GetName(),
+				PipelineRun:             pr,
+				OriginalPipelineRunName: pr.GetAnnotations()[keys.OriginalPRName],
+			}
+
+			if err := vcx.CreateStatus(ctx, r.event, status); err != nil {
+				return fmt.Errorf("cannot use the API on the provider platform to create a in_progress status: %w", err)
+			}
+		}
+	}
 	// if pipelineRun is in completed or failed state then return
 	state, exist := pr.GetAnnotations()[keys.State]
 	if exist && (state == kubeinteraction.StateCompleted || state == kubeinteraction.StateFailed) {
@@ -117,20 +164,60 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, pr *tektonv1.PipelineRun
 	// use same pac opts across the reconciliation
 	pacInfo := r.run.Info.GetPacOpts()
 
+	if repo, err := r.reportFinalStatus(ctx, logger, &pacInfo, r.event, pr, vcx); err != nil {
+		msg := fmt.Sprintf("report status: %v", err)
+		r.eventEmitter.EmitMessage(repo, zap.ErrorLevel, "RepositoryReportFinalStatus", msg)
+		return err
+	}
+	return nil
+}
+
+func (r *Reconciler) getProvider(ctx context.Context, pr *tektonv1.PipelineRun, logger *zap.SugaredLogger) (provider.Interface, error) {
+	pacInfo := r.run.Info.GetPacOpts()
 	detectedProvider, event, err := r.detectProvider(ctx, logger, pr)
 	if err != nil {
-		msg := fmt.Sprintf("detectProvider: %v", err)
+		msg := fmt.Sprintf("det}ectProvider: %v", err)
 		r.eventEmitter.EmitMessage(nil, zap.ErrorLevel, "RepositoryDetectProvider", msg)
-		return nil
+		return nil, err
 	}
 	detectedProvider.SetPacInfo(&pacInfo)
 
-	if repo, err := r.reportFinalStatus(ctx, logger, &pacInfo, event, pr, detectedProvider); err != nil {
-		msg := fmt.Sprintf("report status: %v", err)
-		r.eventEmitter.EmitMessage(repo, zap.ErrorLevel, "RepositoryReportFinalStatus", msg)
-		return err
+	repoName := pr.GetAnnotations()[keys.Repository]
+	repo, err := r.repoLister.Repositories(pr.Namespace).Get(repoName)
+	if err != nil {
+		return nil, fmt.Errorf("reportFinalStatus: %w", err)
 	}
-	return nil
+
+	if event.InstallationID > 0 {
+		event.Provider.WebhookSecret, _ = pac.GetCurrentNSWebhookSecret(ctx, r.kinteract, r.run)
+	} else {
+		secretNS := repo.GetNamespace()
+		if repo.Spec.GitProvider != nil && repo.Spec.GitProvider.Secret == nil && r.globalRepo != nil && r.globalRepo.Spec.GitProvider != nil && r.globalRepo.Spec.GitProvider.Secret != nil {
+			secretNS = r.globalRepo.GetNamespace()
+		}
+		secretFromRepo := pac.SecretFromRepository{
+			K8int:       r.kinteract,
+			Config:      detectedProvider.GetConfig(),
+			Event:       event,
+			Repo:        repo,
+			WebhookType: pacInfo.WebhookType,
+			Logger:      logger,
+			Namespace:   secretNS,
+		}
+		if err := secretFromRepo.Get(ctx); err != nil {
+			return nil, fmt.Errorf("cannot get secret from repository: %w", err)
+		}
+	}
+
+	err = detectedProvider.SetClient(ctx, r.run, event, repo, r.eventEmitter)
+	if err != nil {
+		return nil, fmt.Errorf("cannot set client: %w", err)
+	}
+
+	r.event = event
+	r.repo = repo
+
+	return detectedProvider, nil
 }
 
 func (r *Reconciler) reportFinalStatus(ctx context.Context, logger *zap.SugaredLogger, pacInfo *info.PacOpts, event *info.Event, pr *tektonv1.PipelineRun, provider provider.Interface) (*v1alpha1.Repository, error) {
@@ -156,28 +243,6 @@ func (r *Reconciler) reportFinalStatus(ctx context.Context, logger *zap.SugaredL
 	}
 	r.run.Clients.ConsoleUI().SetParams(maptemplate)
 
-	if event.InstallationID > 0 {
-		event.Provider.WebhookSecret, _ = pac.GetCurrentNSWebhookSecret(ctx, r.kinteract, r.run)
-	} else {
-		secretFromRepo := pac.SecretFromRepository{
-			K8int:       r.kinteract,
-			Config:      provider.GetConfig(),
-			Event:       event,
-			Repo:        repo,
-			WebhookType: pacInfo.WebhookType,
-			Logger:      logger,
-			Namespace:   r.secretNS,
-		}
-		if err := secretFromRepo.Get(ctx); err != nil {
-			return repo, fmt.Errorf("cannot get secret from repository: %w", err)
-		}
-	}
-
-	err = provider.SetClient(ctx, r.run, event, repo, r.eventEmitter)
-	if err != nil {
-		return repo, fmt.Errorf("cannot set client: %w", err)
-	}
-
 	finalState := kubeinteraction.StateCompleted
 	newPr, err := r.postFinalStatus(ctx, logger, pacInfo, provider, event, pr)
 	if err != nil {

pkg/test/provider/testwebvcs.go

@@ -128,3 +128,7 @@ func (v *TestProviderImp) CreateToken(_ context.Context, _ []string, _ *info.Eve
 func (v *TestProviderImp) GetTemplate(commentType provider.CommentType) string {
 	return provider.GetHTMLTemplate(commentType)
 }
+
+func (v *TestProviderImp) GetStatus(_ context.Context, _ *info.Event, _ string) (string, error) {
+	return "", nil
+}