executor

type CacheKeyer interface {
	Key() (string, error)
	Slug() string
}

type Coordinator struct {
	// contains filtered or unexported fields
}

type ExecutionCache interface {
	Get(ctx context.Context, key CacheKeyer) (result executionResult, found bool, err error)
	Set(ctx context.Context, key CacheKeyer, result executionResult) error

	GetStepResult(ctx context.Context, key CacheKeyer) (result stepExecutionResult, found bool, err error)
	SetStepResult(ctx context.Context, key CacheKeyer, result stepExecutionResult) error

	Clear(ctx context.Context, key CacheKeyer) error
}

type ExecutionDiskCache struct {
	Dir string
}

type ExecutionNoOpCache struct{}

type NewCoordinatorOpts struct {
	// Dependencies
	ResolveRepoName repoNameResolver
	EnsureImage     imageEnsurer
	Creator         workspace.Creator
	Client          api.Client

	// TODO: We could probably have a wrapper around flags and features,
	// something like ExecutionArgs, that we can pass around
	CacheDir   string
	ClearCache bool
	SkipErrors bool

	// Used by createChangesetSpecs
	Features batches.FeatureFlags

	CleanArchives bool
	Parallelism   int
	Timeout       time.Duration
	KeepLogs      bool
	TempDir       string
}

type NoopStepOutputWriter struct{}

type NoopStepsExecUI struct{}

type StepOutputWriter interface {
	StdoutWriter() io.Writer
	StderrWriter() io.Writer
	Close() error
}

type StepsCacheKey struct {
	*Task
	StepIndex int
}

type StepsExecutionUI interface {
	ArchiveDownloadStarted()
	ArchiveDownloadFinished(error)

	WorkspaceInitializationStarted()
	WorkspaceInitializationFinished()

	SkippingStepsUpto(int)

	StepSkipped(int)

	StepPreparingStart(int)
	StepPreparingSuccess(int)
	StepPreparingFailed(int, error)
	StepStarted(stepIdx int, runScript string, env map[string]string)

	StepOutputWriter(context.Context, *Task, int) StepOutputWriter

	CalculatingDiffStarted()
	CalculatingDiffFinished()

	StepFinished(idx int, diff []byte, changes *git.Changes, outputs map[string]interface{})
	StepFailed(idx int, err error, exitCode int)
}

type Task struct {
	Repository *graphql.Repository

	// Path is the folder relative to the repository's root in which the steps
	// should be executed. "" means root.
	Path string
	// OnlyFetchWorkspace determines whether the repository archive contains
	// the complete repository or just the files in Path (and additional files,
	// see RepoFetcher).
	// If Path is "" then this setting has no effect.
	OnlyFetchWorkspace bool

	Steps []batcheslib.Step

	// TODO(mrnugget): this should just be a single BatchSpec field instead, if
	// we can make it work with caching
	BatchChangeAttributes *template.BatchChangeAttributes `json:"-"`
	Template              *batcheslib.ChangesetTemplate   `json:"-"`
	TransformChanges      *batcheslib.TransformChanges    `json:"-"`

	Archive repozip.Archive `json:"-"`

	CachedResultFound bool                `json:"-"`
	CachedResult      stepExecutionResult `json:"-"`
}

type TaskCacheKey struct {
	*Task
}

type TaskExecutionErr struct {
	Err        error
	Logfile    string
	Repository string
}

type TaskExecutionUI interface {
	Start([]*Task)
	Success()
	Failed(err error)

	TaskStarted(*Task)
	TaskFinished(*Task, error)

	TaskChangesetSpecsBuilt(*Task, []*batcheslib.ChangesetSpec)

	StepsExecutionUI(*Task) StepsExecutionUI
}