✨ : add retry in job workflow

src/main/java/io/codeka/gaia/runner/StackRunner.java

@@ -136,6 +136,17 @@ public void apply(JobWorkflow jobWorkflow, TerraformModule module, Stack stack)
         );
     }
 
+    @Async
+    public void retry(JobWorkflow jobWorkflow, TerraformModule module, Stack stack) {
+        stepRepository.deleteByJobId(jobWorkflow.getJob().getId());
+        treatJob(
+                jobWorkflow,
+                JobWorkflow::retry,
+                () -> managePlanScript(jobWorkflow.getJob().getType(), stack, module),
+                result -> managePlanResult(result, jobWorkflow, stack)
+        );
+    }
+
     public Job getJob(String jobId) {
         if (this.jobs.containsKey(jobId)) {
             // try in memory

src/main/java/io/codeka/gaia/stacks/bo/Job.java

@@ -47,6 +47,13 @@ public void end(JobStatus jobStatus) {
         this.status = jobStatus;
     }
 
+    public void reset() {
+        this.status = null;
+        this.startDateTime = null;
+        this.endDateTime = null;
+        this.steps.clear();
+    }
+
     public String getId() {
         return id;
     }

src/main/java/io/codeka/gaia/stacks/controller/JobRestController.java

@@ -32,12 +32,12 @@ public JobRestController(JobRepository jobRepository, StackRepository stackRepos
     }
 
     @GetMapping(params = "stackId")
-    public List<Job> jobs(@RequestParam String stackId){
+    public List<Job> jobs(@RequestParam String stackId) {
         return this.jobRepository.findAllByStackId(stackId);
     }
 
     @GetMapping("/{id}")
-    public Job job(@PathVariable String id){
+    public Job job(@PathVariable String id) {
         return this.jobRepository.findById(id).orElseThrow(JobNotFoundException::new);
     }
 
@@ -54,8 +54,17 @@ public void planOrApplyJob(@PathVariable String id, @PathVariable StepType stepT
         }
     }
 
+    @PostMapping("/{id}/retry")
+    public void retryJob(@PathVariable String id) {
+        var job = this.jobRepository.findById(id).orElseThrow(JobNotFoundException::new);
+        var stack = this.stackRepository.findById(job.getStackId()).orElseThrow();
+        var module = this.moduleRepository.findById(stack.getModuleId()).orElseThrow();
+
+        this.stackRunner.retry(new JobWorkflow(job), module, stack);
+    }
+
 }
 
 @ResponseStatus(HttpStatus.NOT_FOUND)
-class JobNotFoundException extends RuntimeException{
+class JobNotFoundException extends RuntimeException {
 }

src/main/java/io/codeka/gaia/stacks/repository/StepRepository.java

@@ -9,4 +9,7 @@
  */
 @Repository
 public interface StepRepository extends MongoRepository<Step, String> {
+
+    void deleteByJobId(String jobId);
+
 }

src/main/java/io/codeka/gaia/stacks/workflow/JobWorkflow.java

@@ -37,6 +37,10 @@ public void fail() {
         this.state.fail(this);
     }
 
+    public void retry() {
+        this.state.retry(this);
+    }
+
     public Job getJob() {
         return job;
     }

src/main/java/io/codeka/gaia/stacks/workflow/state/ApplyFailedState.java

@@ -5,7 +5,7 @@
 /**
  * Describes a job which apply has been failed
  */
-public class ApplyFailedState implements JobState {
+public class ApplyFailedState extends RetryableState implements JobState {
     @Override
     public void plan(JobWorkflow jobWorkflow) {
         throw new UnsupportedOperationException("Unable to start a plan after an apply failed");

src/main/java/io/codeka/gaia/stacks/workflow/state/ApplyFinishedState.java

@@ -25,4 +25,9 @@ public void end(JobWorkflow jobWorkflow) {
     public void fail(JobWorkflow jobWorkflow) {
         throw new UnsupportedOperationException("Unable to fail an apply finished");
     }
+
+    @Override
+    public void retry(JobWorkflow jobWorkflow) {
+        throw new UnsupportedOperationException("Unable to retry a job after an apply finished");
+    }
 }

src/main/java/io/codeka/gaia/stacks/workflow/state/ApplyStartedState.java

@@ -30,4 +30,9 @@ public void fail(JobWorkflow jobWorkflow) {
         jobWorkflow.getJob().end(JobStatus.APPLY_FAILED);
         jobWorkflow.setState(new ApplyFailedState());
     }
+
+    @Override
+    public void retry(JobWorkflow jobWorkflow) {
+        throw new UnsupportedOperationException("Unable to retry a job after an apply started");
+    }
 }

src/main/java/io/codeka/gaia/stacks/workflow/state/JobState.java

@@ -15,4 +15,5 @@ public interface JobState {
 
     void fail(JobWorkflow jobWorkflow);
 
+    void retry(JobWorkflow jobWorkflow);
 }

src/main/java/io/codeka/gaia/stacks/workflow/state/NotStartedState.java

@@ -35,4 +35,9 @@ public void end(JobWorkflow jobWorkflow) {
     public void fail(JobWorkflow jobWorkflow) {
         throw new UnsupportedOperationException("Unable to fail the step of a job not even started");
     }
+
+    @Override
+    public void retry(JobWorkflow jobWorkflow) {
+        throw new UnsupportedOperationException("Unable to retry a job not even started");
+    }
 }

src/main/java/io/codeka/gaia/stacks/workflow/state/PlanFailedState.java

@@ -5,7 +5,7 @@
 /**
  * Describes a job which plan has been failed
  */
-public class PlanFailedState implements JobState {
+public class PlanFailedState extends RetryableState implements JobState {
     @Override
     public void plan(JobWorkflow jobWorkflow) {
         throw new UnsupportedOperationException("Unable to start a plan after a plan failed");

src/main/java/io/codeka/gaia/stacks/workflow/state/PlanFinishedState.java

@@ -29,11 +29,16 @@ public void apply(JobWorkflow jobWorkflow) {
 
     @Override
     public void end(JobWorkflow jobWorkflow) {
-        throw new UnsupportedOperationException("Unable to end an plan finished");
+        throw new UnsupportedOperationException("Unable to end a plan finished");
     }
 
     @Override
     public void fail(JobWorkflow jobWorkflow) {
-        throw new UnsupportedOperationException("Unable to fail an plan finished");
+        throw new UnsupportedOperationException("Unable to fail a plan finished");
+    }
+
+    @Override
+    public void retry(JobWorkflow jobWorkflow) {
+        throw new UnsupportedOperationException("Unable to retry a job after a plan finished");
     }
 }

src/main/java/io/codeka/gaia/stacks/workflow/state/PlanStartedState.java

@@ -30,4 +30,9 @@ public void fail(JobWorkflow jobWorkflow) {
         jobWorkflow.getJob().end(JobStatus.PLAN_FAILED);
         jobWorkflow.setState(new PlanFailedState());
     }
+
+    @Override
+    public void retry(JobWorkflow jobWorkflow) {
+        throw new UnsupportedOperationException("Unable to retry a job after a plan started");
+    }
 }

src/main/java/io/codeka/gaia/stacks/workflow/state/RetryableState.java

@@ -0,0 +1,11 @@
+package io.codeka.gaia.stacks.workflow.state;
+
+import io.codeka.gaia.stacks.workflow.JobWorkflow;
+
+abstract class RetryableState {
+    public final void retry(JobWorkflow jobWorkflow) {
+        jobWorkflow.getJob().reset();
+        jobWorkflow.setState(new NotStartedState());
+        jobWorkflow.plan();
+    }
+}

src/test/java/io/codeka/gaia/runner/StackRunnerTest.java

@@ -267,6 +267,132 @@ void apply_shouldSaveJobAndSteps() {
         verify(stepRepository, times(2)).saveAll(job.getSteps());
     }
 
+    @Test
+    void retry_shouldDeletePreviousSteps() {
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(0);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(stepRepository).deleteByJobId(jobWorkflow.getJob().getId());
+    }
+
+    @Test
+    void retry_shouldExecuteRetryWorkflow() {
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(0);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(jobWorkflow).retry();
+    }
+
+    @Test
+    void retry_shouldUsePlanScript_WhenJobIsRun() {
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(0);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(stackCommandBuilder).buildPlanScript(stack, module);
+    }
+
+    @Test
+    void retry_shouldUsePlanDestroyScript_WhenJobIsStop() {
+        // given
+        job.setType(JobType.DESTROY);
+
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(0);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(stackCommandBuilder).buildPlanDestroyScript(stack, module);
+    }
+
+    @Test
+    void retry_shouldEndJob_WhenSuccessful() {
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(0);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(jobWorkflow).end();
+    }
+
+    @Test
+    void retry_shouldEndJob_WhenThereIsADiff() {
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(2);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(jobWorkflow).end();
+    }
+
+    @Test
+    void retry_shouldFailJob_WhenThereIsAError() {
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(99);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(jobWorkflow).fail();
+    }
+
+    @Test
+    void retry_shouldUpdateStack_WhenThereIsADiff() {
+        // given
+        stack.setState(StackState.RUNNING);
+
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(2);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        assertEquals(StackState.TO_UPDATE, stack.getState());
+        verify(stackRepository).save(stack);
+    }
+
+    @Test
+    void retry_shouldNotUpdateStack_WhenThereIsADiffForNewStacks() {
+        // given
+        stack.setState(StackState.NEW);
+
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(2);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        assertEquals(StackState.NEW, stack.getState());
+        verifyZeroInteractions(stackRepository);
+    }
+
+    @Test
+    void retry_shouldNotUpdateStack_WhenThereIsADiffAndJobIsStop() {
+        // given
+        stack.setState(StackState.RUNNING);
+        job.setType(JobType.DESTROY);
+
+        // when
+        when(dockerRunner.runContainerForJob(any(), any())).thenReturn(2);
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        assertEquals(StackState.RUNNING, stack.getState());
+        verifyZeroInteractions(stackRepository);
+    }
+
+    @Test
+    void retry_shouldSaveJobAndSteps() {
+        // when
+        stackRunner.retry(jobWorkflow, module, stack);
+
+        // then
+        verify(jobRepository, times(2)).save(job);
+        verify(stepRepository, times(2)).saveAll(job.getSteps());
+    }
+
     @Test
     void getJob_shouldReturnJob_whenNotInMemory() {
         // when