diff --git a/pkg/digger/digger.go b/pkg/digger/digger.go index 98dda5d91..f60450b14 100644 --- a/pkg/digger/digger.go +++ b/pkg/digger/digger.go @@ -341,19 +341,19 @@ func parseProjectName(comment string) string { } type DiggerExecutor struct { - repoOwner string - repoName string - projectName string - projectPath string - stateEnvVars map[string]string - commandEnvVars map[string]string - applyStage *configuration.Stage - planStage *configuration.Stage - commandRunner CommandRun - terraformExecutor terraform.TerraformExecutor - prManager ci.CIService - lock utils.ProjectLock - planStorage utils.PlanStorage + RepoOwner string + RepoName string + ProjectName string + ProjectPath string + StateEnvVars map[string]string + CommandEnvVars map[string]string + ApplyStage *configuration.Stage + PlanStage *configuration.Stage + CommandRunner CommandRun + TerraformExecutor terraform.TerraformExecutor + ciService ci.CIService + ProjectLock utils.ProjectLock + PlanStorage utils.PlanStorage } type CommandRun interface { @@ -384,19 +384,19 @@ func (c CommandRunner) Run(command string) (string, string, error) { } func (d DiggerExecutor) planFileName() string { - return d.repoName + "#" + d.projectName + ".tfplan" + return d.RepoName + "#" + d.ProjectName + ".tfplan" } func (d DiggerExecutor) localPlanFilePath() string { - return path.Join(d.projectPath, d.planFileName()) + return path.Join(d.ProjectPath, d.planFileName()) } func (d DiggerExecutor) storedPlanFilePath() string { - return path.Join(d.repoOwner, d.planFileName()) + return path.Join(d.RepoOwner, d.planFileName()) } func (d DiggerExecutor) Plan(prNumber int) error { - res, err := d.lock.Lock(prNumber) + res, err := d.ProjectLock.Lock(prNumber) if err != nil { return fmt.Errorf("error locking project: %v", err) } @@ -404,8 +404,8 @@ func (d DiggerExecutor) Plan(prNumber int) error { if res { var planSteps []configuration.Step - if d.planStage != nil { - planSteps = d.planStage.Steps + if d.PlanStage != nil { + planSteps = d.PlanStage.Steps } else { planSteps = []configuration.Step{ { @@ -418,7 +418,7 @@ func (d DiggerExecutor) Plan(prNumber int) error { } for _, step := range planSteps { if step.Action == "init" { - _, _, err := d.terraformExecutor.Init(step.ExtraArgs, d.stateEnvVars) + _, _, err := d.TerraformExecutor.Init(step.ExtraArgs, d.StateEnvVars) if err != nil { return fmt.Errorf("error running init: %v", err) } @@ -426,23 +426,23 @@ func (d DiggerExecutor) Plan(prNumber int) error { if step.Action == "plan" { planArgs := []string{"-out", d.planFileName()} planArgs = append(planArgs, step.ExtraArgs...) - isNonEmptyPlan, stdout, stderr, err := d.terraformExecutor.Plan(planArgs, d.commandEnvVars) + isNonEmptyPlan, stdout, stderr, err := d.TerraformExecutor.Plan(planArgs, d.CommandEnvVars) if err != nil { return fmt.Errorf("error executing plan: %v", err) } - if d.planStorage != nil { - err = d.planStorage.StorePlan(d.localPlanFilePath(), d.storedPlanFilePath()) + if d.PlanStorage != nil { + err = d.PlanStorage.StorePlan(d.localPlanFilePath(), d.storedPlanFilePath()) if err != nil { return fmt.Errorf("error storing plan: %v", err) } } plan := cleanupTerraformPlan(isNonEmptyPlan, err, stdout, stderr) - comment := utils.GetTerraformOutputAsCollapsibleComment("Plan for **"+d.lock.LockId()+"**", plan) - d.prManager.PublishComment(prNumber, comment) + comment := utils.GetTerraformOutputAsCollapsibleComment("Plan for **"+d.ProjectLock.LockId()+"**", plan) + d.ciService.PublishComment(prNumber, comment) } if step.Action == "run" { - stdout, stderr, err := d.commandRunner.Run(step.Value) - log.Printf("Running %v for **%v**\n%v%v", step.Value, d.lock.LockId(), stdout, stderr) + stdout, stderr, err := d.CommandRunner.Run(step.Value) + log.Printf("Running %v for **%v**\n%v%v", step.Value, d.ProjectLock.LockId(), stdout, stderr) if err != nil { return fmt.Errorf("error running command: %v", err) } @@ -454,29 +454,29 @@ func (d DiggerExecutor) Plan(prNumber int) error { func (d DiggerExecutor) Apply(prNumber int) error { var plansFilename *string - if d.planStorage != nil { + if d.PlanStorage != nil { var err error - plansFilename, err = d.planStorage.RetrievePlan(d.localPlanFilePath(), d.storedPlanFilePath()) + plansFilename, err = d.PlanStorage.RetrievePlan(d.localPlanFilePath(), d.storedPlanFilePath()) if err != nil { return fmt.Errorf("error retrieving plan: %v", err) } } - isMergeable, _, err := d.prManager.IsMergeable(prNumber) + isMergeable, _, err := d.ciService.IsMergeable(prNumber) if err != nil { return fmt.Errorf("error validating is PR is mergeable: %v", err) } if !isMergeable { comment := "Cannot perform Apply since the PR is not currently mergeable." - d.prManager.PublishComment(prNumber, comment) + d.ciService.PublishComment(prNumber, comment) } else { - if res, _ := d.lock.Lock(prNumber); res { + if res, _ := d.ProjectLock.Lock(prNumber); res { var applySteps []configuration.Step - if d.applyStage != nil { - applySteps = d.applyStage.Steps + if d.ApplyStage != nil { + applySteps = d.ApplyStage.Steps } else { applySteps = []configuration.Step{ { @@ -490,24 +490,24 @@ func (d DiggerExecutor) Apply(prNumber int) error { for _, step := range applySteps { if step.Action == "init" { - _, _, err := d.terraformExecutor.Init(step.ExtraArgs, d.stateEnvVars) + _, _, err := d.TerraformExecutor.Init(step.ExtraArgs, d.StateEnvVars) if err != nil { return fmt.Errorf("error running init: %v", err) } } if step.Action == "apply" { - stdout, stderr, err := d.terraformExecutor.Apply(step.ExtraArgs, plansFilename, d.commandEnvVars) + stdout, stderr, err := d.TerraformExecutor.Apply(step.ExtraArgs, plansFilename, d.CommandEnvVars) applyOutput := cleanupTerraformApply(true, err, stdout, stderr) - comment := utils.GetTerraformOutputAsCollapsibleComment("Apply for **"+d.lock.LockId()+"**", applyOutput) - d.prManager.PublishComment(prNumber, comment) + comment := utils.GetTerraformOutputAsCollapsibleComment("Apply for **"+d.ProjectLock.LockId()+"**", applyOutput) + d.ciService.PublishComment(prNumber, comment) if err != nil { - d.prManager.PublishComment(prNumber, "Error during applying.") + d.ciService.PublishComment(prNumber, "Error during applying.") return fmt.Errorf("error executing apply: %v", err) } } if step.Action == "run" { - stdout, stderr, err := d.commandRunner.Run(step.Value) - log.Printf("Running %v for **%v**\n%v%v", step.Value, d.lock.LockId(), stdout, stderr) + stdout, stderr, err := d.CommandRunner.Run(step.Value) + log.Printf("Running %v for **%v**\n%v%v", step.Value, d.ProjectLock.LockId(), stdout, stderr) if err != nil { return fmt.Errorf("error running command: %v", err) } @@ -519,11 +519,11 @@ func (d DiggerExecutor) Apply(prNumber int) error { } func (d DiggerExecutor) Unlock(prNumber int) error { - err := d.lock.ForceUnlock(prNumber) + err := d.ProjectLock.ForceUnlock(prNumber) if err != nil { - return fmt.Errorf("failed to aquire lock: %s, %v", d.lock.LockId(), err) + return fmt.Errorf("failed to aquire lock: %s, %v", d.ProjectLock.LockId(), err) } - err = d.planStorage.DeleteStoredPlan(d.storedPlanFilePath()) + err = d.PlanStorage.DeleteStoredPlan(d.storedPlanFilePath()) if err != nil { return fmt.Errorf("failed to delete stored plan file '%v': %v", d.storedPlanFilePath(), err) } @@ -531,9 +531,9 @@ func (d DiggerExecutor) Unlock(prNumber int) error { } func (d DiggerExecutor) Lock(prNumber int) error { - _, err := d.lock.Lock(prNumber) + _, err := d.ProjectLock.Lock(prNumber) if err != nil { - return fmt.Errorf("failed to aquire lock: %s, %v", d.lock.LockId(), err) + return fmt.Errorf("failed to aquire lock: %s, %v", d.ProjectLock.LockId(), err) } return nil } diff --git a/pkg/digger/digger_test.go b/pkg/digger/digger_test.go index 564516034..75ded76f8 100644 --- a/pkg/digger/digger_test.go +++ b/pkg/digger/digger_test.go @@ -151,7 +151,7 @@ func TestCorrectCommandExecutionWhenApplying(t *testing.T) { lock := &MockProjectLock{} planStorage := &MockPlanStorage{} executor := DiggerExecutor{ - applyStage: &configuration.Stage{ + ApplyStage: &configuration.Stage{ Steps: []configuration.Step{ { Action: "init", @@ -170,12 +170,12 @@ func TestCorrectCommandExecutionWhenApplying(t *testing.T) { }, }, }, - planStage: &configuration.Stage{}, - commandRunner: commandRunner, - terraformExecutor: terraformExecutor, - prManager: prManager, - lock: lock, - planStorage: planStorage, + PlanStage: &configuration.Stage{}, + CommandRunner: commandRunner, + TerraformExecutor: terraformExecutor, + ciService: prManager, + ProjectLock: lock, + PlanStorage: planStorage, } executor.Apply(1) @@ -193,8 +193,8 @@ func TestCorrectCommandExecutionWhenPlanning(t *testing.T) { planStorage := &MockPlanStorage{} executor := DiggerExecutor{ - applyStage: &configuration.Stage{}, - planStage: &configuration.Stage{ + ApplyStage: &configuration.Stage{}, + PlanStage: &configuration.Stage{ Steps: []configuration.Step{ { Action: "init", @@ -213,11 +213,11 @@ func TestCorrectCommandExecutionWhenPlanning(t *testing.T) { }, }, }, - commandRunner: commandRunner, - terraformExecutor: terraformExecutor, - prManager: prManager, - lock: lock, - planStorage: planStorage, + CommandRunner: commandRunner, + TerraformExecutor: terraformExecutor, + ciService: prManager, + ProjectLock: lock, + PlanStorage: planStorage, } executor.Plan(1)