Implement step-wise caching for batch spec execution (#540)

This adds step-wise caching for the execution of batch specs.

In short, given a batch spec that contains the following

```yaml
on:
  - repository: github.com/sourcegraph/automation-testing
  - repository: github.com/sourcegraph-testing/mkcert

steps:
  - run: echo "this is step 1" >> caching.txt
    container: alpine:3
  - run: echo "this is step 2" >> README.md
    container: alpine:3
  - run: echo "this is step 3" >> README.md
    container: alpine:3
    outputs:
      myOutput:
        value: "what is up"
  - run: echo "this is step 4" >> caching.txt
    if: ${{ eq repository.name "github.com/sourcegraph/automation-testing" }}
    container: alpine:3
```

this PR would cause `src` to cache the results _per step and per repository.

In practice, this means that if we would change the batch spec from the above so it would look like this

```yaml
steps:
  - run: echo "this is step 0" >> caching.txt
    container: alpine:3
  - run: echo "this is step 1" >> README.md
    container: alpine:3
    #                         vvvv LOOK HERE vvv
  - run: echo "this is step 2 WITH A CHANGE" >> README.md
    container: alpine:3
    outputs:
      myOutput:
        value: "what is up"
  - run: echo "this is step 3" >> caching.txt
    if: ${{ eq repository.name "github.com/sourcegraph/automation-testing" }}
    container: alpine:3
```

and we'd then re-execute the batch spec, **the steps 0 and 1 would not need to be re-executed**. Only step 2 would need to be re-executed for both repositories and step 3 would only need to be re-executed for both repositories.

Author: mrnugget

CHANGELOG.md

@@ -15,6 +15,8 @@ All notable changes to `src-cli` are documented in this file.
 
 ### Changed
 
+- `src batch [apply|preview]` now cache the results of each step when executing a batch spec. That can make re-execution a lot faster when only a subset of the steps has been changed. [#540](https://github.com/sourcegraph/src-cli/pull/540)
+
 ### Fixed
 
 ### Removed

internal/batches/executor/changeset_specs_test.go

@@ -8,22 +8,15 @@ import (
 	"github.com/sourcegraph/batch-change-utils/overridable"
 	"github.com/sourcegraph/src-cli/internal/batches"
 	"github.com/sourcegraph/src-cli/internal/batches/git"
-	"github.com/sourcegraph/src-cli/internal/batches/graphql"
 )
 
 func TestCreateChangesetSpecs(t *testing.T) {
-	srcCLI := &graphql.Repository{
-		ID:            "src-cli",
-		Name:          "github.com/sourcegraph/src-cli",
-		DefaultBranch: &graphql.Branch{Name: "main", Target: graphql.Target{OID: "d34db33f"}},
-	}
-
 	defaultChangesetSpec := &batches.ChangesetSpec{
-		BaseRepository: srcCLI.ID,
+		BaseRepository: testRepo1.ID,
 		CreatedChangeset: &batches.CreatedChangeset{
-			BaseRef:        srcCLI.DefaultBranch.Name,
-			BaseRev:        srcCLI.DefaultBranch.Target.OID,
-			HeadRepository: srcCLI.ID,
+			BaseRef:        testRepo1.DefaultBranch.Name,
+			BaseRev:        testRepo1.DefaultBranch.Target.OID,
+			HeadRepository: testRepo1.ID,
 			HeadRef:        "refs/heads/my-branch",
 			Title:          "The title",
 			Body:           "The body",
@@ -58,7 +51,7 @@ func TestCreateChangesetSpecs(t *testing.T) {
 			},
 			Published: parsePublishedFieldString(t, "false"),
 		},
-		Repository: srcCLI,
+		Repository: testRepo1,
 	}
 
 	taskWith := func(t *Task, f func(t *Task)) *Task {

internal/batches/executor/coordinator.go

@@ -28,7 +28,7 @@ type Coordinator struct {
 
 	cache      ExecutionCache
 	exec       taskExecutor
-	logManager *log.Manager
+	logManager log.LogManager
 }
 
 type repoNameResolver func(ctx context.Context, name string) (*graphql.Repository, error)
@@ -154,6 +154,14 @@ func (c *Coordinator) cacheAndBuildSpec(ctx context.Context, taskResult taskResu
 		return nil, errors.Wrapf(err, "caching result for %q", taskResult.task.Repository.Name)
 	}
 
+	// Save the per-step results
+	for _, stepResult := range taskResult.stepResults {
+		key := StepsCacheKey{Task: taskResult.task, StepIndex: stepResult.StepIndex}
+		if err := c.cache.SetStepResult(ctx, key, stepResult); err != nil {
+			return nil, errors.Wrapf(err, "caching result for step %d in %q", stepResult.StepIndex, taskResult.task.Repository.Name)
+		}
+	}
+
 	// If the steps didn't result in any diff, we don't need to create a
 	// changeset spec that's displayed to the user and send to the server.
 	if taskResult.result.Diff == "" {
@@ -203,6 +211,27 @@ func (c *Coordinator) Execute(ctx context.Context, tasks []*Task, spec *batches.
 		}()
 	}
 
+	// If we are here, that means we didn't find anything in the cache for the
+	// complete task. So, what if we have cached results for the steps?
+	for _, t := range tasks {
+		// We start at the back so that we can find the _last_ cached step,
+		// then restart execution on the following step.
+		for i := len(t.Steps) - 1; i > -1; i-- {
+			key := StepsCacheKey{Task: t, StepIndex: i}
+
+			result, found, err := c.cache.GetStepResult(ctx, key)
+			if err != nil {
+				return nil, nil, errors.Wrapf(err, "checking for cached diff for step %d", i)
+			}
+
+			if found {
+				t.CachedResultFound = true
+				t.CachedResult = result
+				break
+			}
+		}
+	}
+
 	// Run executor
 	c.exec.Start(ctx, tasks, status)
 	results, err := c.exec.Wait(ctx)