WIP: support single comment summary with orchestrator mode

backend/controllers/github.go

@@ -34,9 +34,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
-	"path/filepath"
 	"reflect"
-	"runtime/debug"
 	"slices"
 	"strconv"
 	"strings"
@@ -430,6 +428,7 @@ func handlePullRequestEvent(gh utils.GithubClientProvider, payload *github.PullR
 			return fmt.Errorf("error processing event")
 		}
 	}
+
 	diggerCommand, err := orchestrator_scheduler.GetCommandFromJob(jobsForImpactedProjects[0])
 	if err != nil {
 		log.Printf("could not determine digger command from job: %v", jobsForImpactedProjects[0].Commands)
@@ -523,6 +522,15 @@ func handlePullRequestEvent(gh utils.GithubClientProvider, payload *github.PullR
 	}
 
 	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGithub, organisationId, impactedJobsMap, impactedProjectsMap, projectsGraph, installationId, branch, prNumber, repoOwner, repoName, repoFullName, commitSha, commentId, diggerYmlStr, 0, aiSummaryCommentId, config.ReportTerraformOutputs)
+
+	placeholderComment, err := ghService.PublishComment(prNumber, "digger report placehoder")
+	if err != nil {
+		log.Printf("strconv.ParseInt error: %v", err)
+		commentReporterManager.UpdateComment(fmt.Sprintf(":x: could not create placeholder commentId for report: %v", err))
+		return fmt.Errorf("comment reporter error: %v", err)
+	}
+
+	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, models.DiggerVCSGithub, organisationId, impactedJobsMap, impactedProjectsMap, projectsGraph, installationId, branch, prNumber, repoOwner, repoName, repoFullName, commitSha, commentId, &placeholderComment.Id, diggerYmlStr, 0)
 	if err != nil {
 		log.Printf("ConvertJobsToDiggerJobs error: %v", err)
 		commentReporterManager.UpdateComment(fmt.Sprintf(":x: ConvertJobsToDiggerJobs error: %v", err))
@@ -931,6 +939,14 @@ func handleIssueCommentEvent(gh utils.GithubClientProvider, payload *github.Issu
 	}
 
 	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, "github", orgId, impactedProjectsJobMap, impactedProjectsMap, projectsGraph, installationId, *branch, issueNumber, repoOwner, repoName, repoFullName, *commitSha, reporterCommentId, diggerYmlStr, 0, aiSummaryCommentId, config.ReportTerraformOutputs)
+	placeholderComment, err := ghService.PublishComment(issueNumber, "digger report placehoder")
+	if err != nil {
+		log.Printf("strconv.ParseInt error: %v", err)
+		commentReporterManager.UpdateComment(fmt.Sprintf(":x: could not create placeholder commentId for report: %v", err))
+		return fmt.Errorf("comment reporter error: %v", err)
+	}
+
+	batchId, _, err := utils.ConvertJobsToDiggerJobs(*diggerCommand, "github", orgId, impactedProjectsJobMap, impactedProjectsMap, projectsGraph, installationId, *branch, issueNumber, repoOwner, repoName, repoFullName, *commitSha, reporterCommentId, &placeholderComment.Id, diggerYmlStr, 0)
 	if err != nil {
 		log.Printf("ConvertJobsToDiggerJobs error: %v", err)
 		commentReporterManager.UpdateComment(fmt.Sprintf(":x: ConvertJobsToDiggerJobs error: %v", err))

backend/migrations/20241204194016.sql

@@ -0,0 +1,2 @@
+-- Modify "digger_batches" table
+ALTER TABLE "public"."digger_batches" ADD COLUMN "placeholder_comment_id_for_report" text NULL;

backend/models/scheduler.go

@@ -22,20 +22,21 @@ const DiggerVCSGithub DiggerVCSType = "github"
 const DiggerVCSGitlab DiggerVCSType = "gitlab"
 
 type DiggerBatch struct {
-	ID                     uuid.UUID `gorm:"primary_key"`
-	VCS                    DiggerVCSType
-	PrNumber               int
-	CommentId              *int64
+	ID                            uuid.UUID `gorm:"primary_key"`
+	VCS                           DiggerVCSType
+	PrNumber                      int
+	CommentId                     *int64
 	AiSummaryCommentId     string
-	Status                 orchestrator_scheduler.DiggerBatchStatus
-	BranchName             string
-	DiggerConfig           string
-	GithubInstallationId   int64
-	GitlabProjectId        int
-	RepoFullName           string
-	RepoOwner              string
-	RepoName               string
-	BatchType              orchestrator_scheduler.DiggerCommand
+	PlaceholderCommentIdForReport *string
+	Status                        orchestrator_scheduler.DiggerBatchStatus
+	BranchName                    string
+	DiggerConfig                  string
+	GithubInstallationId          int64
+	GitlabProjectId               int
+	RepoFullName                  string
+	RepoOwner                     string
+	RepoName                      string
+	BatchType                     orchestrator_scheduler.DiggerCommand
 	ReportTerraformOutputs bool
 	// used for module source grouping comments
 	SourceDetails []byte

backend/models/storage.go

@@ -617,7 +617,7 @@ func (db *Database) GetDiggerBatch(batchId *uuid.UUID) (*DiggerBatch, error) {
 	return batch, nil
 }
 
-func (db *Database) CreateDiggerBatch(vcsType DiggerVCSType, githubInstallationId int64, repoOwner string, repoName string, repoFullname string, PRNumber int, diggerConfig string, branchName string, batchType scheduler.DiggerCommand, commentId *int64, gitlabProjectId int, aiSummaryCommentId string, reportTerraformOutputs bool) (*DiggerBatch, error) {
+func (db *Database) CreateDiggerBatch(vcsType DiggerVCSType, githubInstallationId int64, repoOwner string, repoName string, repoFullname string, PRNumber int, diggerConfig string, branchName string, batchType scheduler.DiggerCommand, commentId *int64, placeholderCommentIdForReport *string, gitlabProjectId int, aiSummaryCommentId string, reportTerraformOutputs bool) (*DiggerBatch, error) {
 	uid := uuid.New()
 	batch := &DiggerBatch{
 		ID:                     uid,
@@ -628,6 +628,7 @@ func (db *Database) CreateDiggerBatch(vcsType DiggerVCSType, githubInstallationI
 		RepoFullName:           repoFullname,
 		PrNumber:               PRNumber,
 		CommentId:              commentId,
+		PlaceholderCommentIdForReport: placeholderCommentIdForReport,
 		Status:                 scheduler.BatchJobCreated,
 		BranchName:             branchName,
 		DiggerConfig:           diggerConfig,

backend/services/spec.go

@@ -116,9 +116,9 @@ func GetSpecFromJob(job models.DiggerJob) (*spec.Spec, error) {
 		CommentId: strconv.FormatInt(*batch.CommentId, 10),
 		Job:       jobSpec,
 		Reporter: spec.ReporterSpec{
-			ReportingStrategy:     "comments_per_run",
-			ReporterType:          "lazy",
-			ReportTerraformOutput: batch.ReportTerraformOutputs,
+			ReportingStrategy: "comments_per_run",
+			ReporterType:      "basic",
+			ReportCommentId:   job.Batch.PlaceholderCommentIdForReport,
 		},
 		Lock: spec.LockSpec{
 			LockType: "noop",

backend/utils/graphs.go

@@ -14,7 +14,7 @@ import (
 )
 
 // ConvertJobsToDiggerJobs jobs is map with project name as a key and a Job as a value
-func ConvertJobsToDiggerJobs(jobType scheduler.DiggerCommand, vcsType models.DiggerVCSType, organisationId uint, jobsMap map[string]scheduler.Job, projectMap map[string]configuration.Project, projectsGraph graph.Graph[string, configuration.Project], githubInstallationId int64, branch string, prNumber int, repoOwner string, repoName string, repoFullName string, commitSha string, commentId int64, diggerConfigStr string, gitlabProjectId int, aiSummaryCommentId string, reportTerraformOutput bool) (*uuid.UUID, map[string]*models.DiggerJob, error) {
+func ConvertJobsToDiggerJobs(jobType scheduler.DiggerCommand, vcsType models.DiggerVCSType, organisationId uint, jobsMap map[string]scheduler.Job, projectMap map[string]configuration.Project, projectsGraph graph.Graph[string, configuration.Project], githubInstallationId int64, branch string, prNumber int, repoOwner string, repoName string, repoFullName string, commitSha string, commentId int64, placeholderCommentIdForReport *string, diggerConfigStr string, gitlabProjectId int, aiSummaryCommentId string, reportTerraformOutput bool) (*uuid.UUID, map[string]*models.DiggerJob, error) {
 	result := make(map[string]*models.DiggerJob)
 	organisation, err := models.DB.GetOrganisationById(organisationId)
 	if err != nil {
@@ -43,7 +43,7 @@ func ConvertJobsToDiggerJobs(jobType scheduler.DiggerCommand, vcsType models.Dig
 
 	log.Printf("marshalledJobsMap: %v\n", marshalledJobsMap)
 
-	batch, err := models.DB.CreateDiggerBatch(vcsType, githubInstallationId, repoOwner, repoName, repoFullName, prNumber, diggerConfigStr, branch, jobType, &commentId, gitlabProjectId, aiSummaryCommentId, reportTerraformOutput)
+	batch, err := models.DB.CreateDiggerBatch(vcsType, githubInstallationId, repoOwner, repoName, repoFullName, prNumber, diggerConfigStr, branch, jobType, &commentId, placeholderCommentIdForReport, gitlabProjectId, aiSummaryCommentId, reportTerraformOutput)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to create batch: %v", err)
 	}

cli/cmd/digger/main_test.go

@@ -895,8 +895,11 @@ func TestGitHubNewPullRequestContext(t *testing.T) {
 	impactedProjects, requestedProject, prNumber, err := dggithub.ProcessGitHubEvent(ghEvent, &diggerConfig, &prManager)
 
 	reporter := &reporting.CiReporter{
-		CiService: &prManager,
-		PrNumber:  prNumber,
+		CiService:         &prManager,
+		PrNumber:          prNumber,
+		IsSupportMarkdown: true,
+		IsSuppressed:      false,
+		ReportStrategy:    reporting.NewMultipleCommentsStrategy(),
 	}
 
 	event := context.Event.(github.PullRequestEvent)
@@ -923,8 +926,11 @@ func TestGitHubNewCommentContext(t *testing.T) {
 	planStorage := storage.MockPlanStorage{}
 	impactedProjects, requestedProject, prNumber, err := dggithub.ProcessGitHubEvent(ghEvent, &diggerConfig, &prManager)
 	reporter := &reporting.CiReporter{
-		CiService: &prManager,
-		PrNumber:  prNumber,
+		CiService:         &prManager,
+		PrNumber:          prNumber,
+		ReportStrategy:    reporting.NewMultipleCommentsStrategy(),
+		IsSuppressed:      false,
+		IsSupportMarkdown: true,
 	}
 
 	policyChecker := policy.MockPolicyChecker{}

cli/cmd/digger/root.go

@@ -14,7 +14,6 @@ import (
 	"log"
 	"net/http"
 	"os"
-	"time"
 )
 
 type RunConfig struct {
@@ -93,15 +92,11 @@ func PreRun(cmd *cobra.Command, args []string) {
 	//PolicyChecker = policy.NewPolicyChecker(hostName, orgName, token)
 
 	if os.Getenv("REPORTING_STRATEGY") == "comments_per_run" || os.Getenv("ACCUMULATE_PLANS") == "true" {
-		ReportStrategy = &reporting.CommentPerRunStrategy{
-			TimeOfRun: time.Now(),
-		}
-	} else if os.Getenv("REPORTING_STRATEGY") == "latest_run_comment" {
-		ReportStrategy = &reporting.LatestRunCommentStrategy{
-			TimeOfRun: time.Now(),
-		}
+		strategy := reporting.NewSingleCommentStrategy()
+		ReportStrategy = &strategy
 	} else {
-		ReportStrategy = &reporting.MultipleCommentsStrategy{}
+		strategy := reporting.NewMultipleCommentsStrategy()
+		ReportStrategy = &strategy
 	}
 
 	var err error

cli/pkg/digger/digger.go

@@ -124,13 +124,14 @@ func RunJobs(jobs []orchestrator.Job, prService ci.PullRequestService, orgServic
 	}
 
 	if allAppliesSuccess == true && reportFinalStatusToBackend == true {
-		_, jobPrCommentUrl, err := reporter.Flush()
+		_, jobPrCommentUrls, err := reporter.Flush()
 		if err != nil {
 			log.Printf("error while sending job comments %v", err)
 			return false, false, fmt.Errorf("error while sending job comments %v", err)
 		}
 
 		currentJob := jobs[0]
+		jobPrCommentUrl := jobPrCommentUrls[0]
 		repoNameForBackendReporting := strings.ReplaceAll(currentJob.Namespace, "/", "-")
 		projectNameForBackendReporting := currentJob.ProjectName
 		// TODO: handle the apply result summary as well to report it to backend. Possibly reporting changed resources as well
@@ -170,12 +171,12 @@ func RunJobs(jobs []orchestrator.Job, prService ci.PullRequestService, orgServic
 func reportPolicyError(projectName string, command string, requestedBy string, reporter reporting.Reporter) string {
 	msg := fmt.Sprintf("User %s is not allowed to perform action: %s. Check your policies :x:", requestedBy, command)
 	if reporter.SupportsMarkdown() {
-		_, _, err := reporter.Report(msg, coreutils.AsCollapsibleComment(fmt.Sprintf("Policy violation for <b>%v - %v</b>", projectName, command), false))
+		err := reporter.Report(projectName, msg, coreutils.AsCollapsibleComment(fmt.Sprintf("Policy violation for <b>%v - %v</b>", projectName, command), false))
 		if err != nil {
 			log.Printf("Error publishing comment: %v", err)
 		}
 	} else {
-		_, _, err := reporter.Report(msg, coreutils.AsComment(fmt.Sprintf("Policy violation for %v - %v", projectName, command)))
+		err := reporter.Report(projectName, msg, coreutils.AsComment(fmt.Sprintf("Policy violation for %v - %v", projectName, command)))
 		if err != nil {
 			log.Printf("Error publishing comment: %v", err)
 		}
@@ -284,7 +285,7 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 			return nil, msg, fmt.Errorf(msg)
 		} else if planPerformed {
 			if isNonEmptyPlan {
-				reportTerraformPlanOutput(reporter, projectLock.LockId(), plan)
+				reportTerraformPlanOutput(reporter, job.ProjectName, plan)
 				planIsAllowed, messages, err := policyChecker.CheckPlanPolicy(SCMrepository, SCMOrganisation, job.ProjectName, job.ProjectDir, planJsonOutput)
 				if err != nil {
 					msg := fmt.Sprintf("Failed to validate plan. %v", err)
@@ -311,7 +312,7 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 						preformattedMessaged = append(preformattedMessaged, fmt.Sprintf("    %v", message))
 					}
 					planReportMessage = planReportMessage + strings.Join(preformattedMessaged, "<br>")
-					_, _, err = reporter.Report(planReportMessage, planPolicyFormatter)
+					err = reporter.Report(job.ProjectName, planReportMessage, planPolicyFormatter)
 
 					if err != nil {
 						log.Printf("Failed to report plan. %v", err)
@@ -320,14 +321,14 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 					log.Printf(msg)
 					return nil, msg, fmt.Errorf(msg)
 				} else {
-					_, _, err := reporter.Report("Terraform plan validation checks succeeded :white_check_mark:", planPolicyFormatter)
+					err := reporter.Report(job.ProjectName, "Terraform plan validation checks succeeded :white_check_mark:", planPolicyFormatter)
 					if err != nil {
 						log.Printf("Failed to report plan. %v", err)
 					}
-					reportPlanSummary(reporter, planSummary)
+					reportPlanSummary(job.ProjectName, reporter, planSummary)
 				}
 			} else {
-				reportEmptyPlanOutput(reporter, projectLock.LockId())
+				reportEmptyPlanOutput(job.ProjectName, reporter, projectLock.LockId())
 			}
 			err := prService.SetStatus(*job.PullRequestNumber, "success", job.ProjectName+"/plan")
 			if err != nil {
@@ -370,7 +371,7 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 		}
 		log.Printf("PR status, mergeable: %v, merged: %v and skipMergeCheck %v\n", isMergeable, isMerged, job.SkipMergeCheck)
 		if !isMergeable && !isMerged && !job.SkipMergeCheck {
-			comment := reportApplyMergeabilityError(reporter)
+			comment := reportApplyMergeabilityError(job.ProjectName, reporter)
 			prService.SetStatus(*job.PullRequestNumber, "failure", job.ProjectName+"/apply")
 
 			return nil, comment, fmt.Errorf(comment)
@@ -491,25 +492,25 @@ func run(command string, job orchestrator.Job, policyChecker policy.Checker, org
 	return &execution.DiggerExecutorResult{}, "", nil
 }
 
-func reportApplyMergeabilityError(reporter reporting.Reporter) string {
+func reportApplyMergeabilityError(projectName string, reporter reporting.Reporter) string {
 	comment := "cannot perform Apply since the PR is not currently mergeable"
 	log.Println(comment)
 
 	if reporter.SupportsMarkdown() {
-		_, _, err := reporter.Report(comment, coreutils.AsCollapsibleComment("Apply error", false))
+		err := reporter.Report(projectName, comment, coreutils.AsCollapsibleComment("Apply error", false))
 		if err != nil {
 			log.Printf("error publishing comment: %v\n", err)
 		}
 	} else {
-		_, _, err := reporter.Report(comment, coreutils.AsComment("Apply error"))
+		err := reporter.Report(projectName, comment, coreutils.AsComment("Apply error"))
 		if err != nil {
 			log.Printf("error publishing comment: %v\n", err)
 		}
 	}
 	return comment
 }
 
-func reportTerraformPlanOutput(reporter reporting.Reporter, projectId string, plan string) {
+func reportTerraformPlanOutput(reporter reporting.Reporter, projectName string, plan string) {
 	var formatter func(string) string
 
 	if reporter.SupportsMarkdown() {
@@ -518,13 +519,13 @@ func reportTerraformPlanOutput(reporter reporting.Reporter, projectId string, pl
 		formatter = coreutils.GetTerraformOutputAsComment("Plan output")
 	}
 
-	_, _, err := reporter.Report(plan, formatter)
+	err := reporter.Report(projectName, plan, formatter)
 	if err != nil {
 		log.Printf("Failed to report plan. %v", err)
 	}
 }
 
-func reportPlanSummary(reporter reporting.Reporter, summary string) {
+func reportPlanSummary(projectName string, reporter reporting.Reporter, summary string) {
 	var formatter func(string) string
 
 	if reporter.SupportsMarkdown() {
@@ -533,19 +534,19 @@ func reportPlanSummary(reporter reporting.Reporter, summary string) {
 		formatter = coreutils.AsComment("Plan summary")
 	}
 
-	_, _, err := reporter.Report("\n"+summary, formatter)
+	err := reporter.Report(projectName, "\n"+summary, formatter)
 	if err != nil {
 		log.Printf("Failed to report plan summary. %v", err)
 	}
 }
 
-func reportEmptyPlanOutput(reporter reporting.Reporter, projectId string) {
+func reportEmptyPlanOutput(projectName string, reporter reporting.Reporter, projectId string) {
 	identityFormatter := func(comment string) string {
 		return comment
 	}
-	_, _, err := reporter.Report("→ No changes in terraform output for "+projectId, identityFormatter)
+	err := reporter.Report(projectName, "→ No changes in terraform output for "+projectId, identityFormatter)
 	// suppress the comment (if reporter is suppressible)
-	reporter.Suppress()
+	reporter.Suppress("")
 	if err != nil {
 		log.Printf("Failed to report plan. %v", err)
 	}

cli/pkg/digger/digger_test.go

@@ -86,7 +86,12 @@ func (m *MockPRManager) GetApprovals(prNumber int) ([]string, error) {
 
 func (m *MockPRManager) PublishComment(prNumber int, comment string) (*ci.Comment, error) {
 	m.Commands = append(m.Commands, RunInfo{"PublishComment", strconv.Itoa(prNumber) + " " + comment, time.Now()})
-	return nil, nil
+	return &ci.Comment{
+		Id:           "",
+		DiscussionId: "",
+		Body:         nil,
+		Url:          "",
+	}, nil
 }
 
 func (m *MockPRManager) ListIssues() ([]*ci.Issue, error) {
@@ -241,16 +246,16 @@ func (m MockPlanPathProvider) LocalPlanFilePath() string {
 }
 
 func TestCorrectCommandExecutionWhenApplying(t *testing.T) {
-
 	commandRunner := &MockCommandRunner{}
 	terraformExecutor := &MockTerraformExecutor{}
 	prManager := &MockPRManager{}
 	lock := &MockProjectLock{}
 	planStorage := &MockPlanStorage{}
+	strategy := reporting.NewMultipleCommentsStrategy()
 	reporter := &reporting.CiReporter{
 		CiService:         prManager,
 		PrNumber:          1,
-		ReportStrategy:    &reporting.MultipleCommentsStrategy{},
+		ReportStrategy:    &strategy,
 		IsSupportMarkdown: true,
 	}
 	planPathProvider := &MockPlanPathProvider{}
@@ -287,7 +292,7 @@ func TestCorrectCommandExecutionWhenApplying(t *testing.T) {
 
 	commandStrings := allCommandsInOrderWithParams(terraformExecutor, commandRunner, prManager, lock, planStorage, planPathProvider)
 
-	assert.Equal(t, []string{"RetrievePlan plan", "Init ", "Apply ", "PublishComment 1 <details ><summary>Apply output</summary>\n\n```terraform\n\n```\n</details>", "Run   echo"}, commandStrings)
+	assert.Equal(t, []string{"RetrievePlan plan", "Init ", "Apply ", "Run   echo"}, commandStrings)
 }
 
 func TestCorrectCommandExecutionWhenDestroying(t *testing.T) {
@@ -297,10 +302,11 @@ func TestCorrectCommandExecutionWhenDestroying(t *testing.T) {
 	prManager := &MockPRManager{}
 	lock := &MockProjectLock{}
 	planStorage := &MockPlanStorage{}
+	strategy := reporting.NewMultipleCommentsStrategy()
 	reporter := &reporting.CiReporter{
 		CiService:      prManager,
 		PrNumber:       1,
-		ReportStrategy: &reporting.MultipleCommentsStrategy{},
+		ReportStrategy: &strategy,
 	}
 	planPathProvider := &MockPlanPathProvider{}
 	executor := execution.DiggerExecutor{