runtime

type CommonRunFlags struct {
	// Assert is the policy used to assert cached flow result compatibility. e.g. never, exact.
	Assert string
	// EvalStrategy is the evaluation strategy. Supported modes are "topdown" and "bottomup".
	EvalStrategy string
	// Invalidate is a regular expression for node identifiers that should be invalidated.
	Invalidate string
	// PostUseChecksum indicates whether input filesets are checksummed after use.
	PostUseChecksum bool
	// RecomputeEmpty indicates if cache results with empty filesets be automatically recomputed.
	RecomputeEmpty bool
}

type Eval struct {
	// InputArgs is the raw input arguments of the evaluation, as passed
	// in by user.
	InputArgs []string
	// Program stores the reflow program's path.
	Program string
	// Params stores the evaluation's module parameters and raw values.
	Params map[string]string
	// Args stores the evaluation's command line arguments.
	Args []string
	// V1 tells whether this program is a "V1" (".rf") program.
	V1 bool
	// Images is the list of images that were parsed from a syntax session.
	Images []string
	// ImageMap stores a mapping between image names and resolved
	// image names, to be used in evaluation.
	ImageMap map[string]string
	// Type is the module type of the toplevel module that has been
	// evaluated.
	Type *types.T
	// Module is the module value that was evaluated.
	Module values.Module
}

type FlagName string

type ImageResolver struct {
	// Authenticator will have a nil AWS session if the config does not have
	// AWS credentials, in which case it is expected that none of the images are
	// ECR images.
	Authenticator ecrauth.Interface
	// contains filtered or unexported fields
}

type ReflowRunner interface {
	Go(context.Context) (runner.State, error)
	GetRunID() taskdb.RunID

	// TODO(swami):  Remove this.
	SetDotWriter(io.Writer)
}

type ReflowRuntime interface {

	// Start starts the reflow runtime.
	// Start uses the provided context to run the necessary background processes,
	// upon cancellation of which, these processes are stopped and the runtime becomes unviable.
	Start(ctx context.Context)

	// WaitDone waits for the reflow runtime to be done (which happens only if ctx to `Start` was cancelled).
	WaitDone()

	// Scheduler returns the underlying scheduler.
	// TODO(swami):  Remove this.  This is exposed temporarily and shouldn't need to be eventually.
	Scheduler() *sched.Scheduler

	// NewRunner returns a new reflow runner.
	NewRunner(RunnerParams) (ReflowRunner, error)
}

type RunConfig struct {
	// Program is the local path to the reflow bundle/program.
	Program string
	// Args is the arguments to be passed to the reflow program in the form of "--<argname>=<value>"
	Args []string
	// RunFlags is the run flags for this run.
	RunFlags RunFlags
	// Config is the config for this run.
	Config infra.Config
}

type RunFlags struct {
	CommonRunFlags
	// LocalDir is the directory where execution state is store in Local mode.
	LocalDir string
	// Dir is the where execution state is stored in local mode (alias for backwards compatibility).
	Dir string
	// Local enables execution using the local docker instance.
	Local bool
	// Trace when set enable tracing flow evaluation.
	Trace bool
	Cache bool
	Pred  bool
	// DotGraph enables computation of an evaluation graph.
	DotGraph bool

	// BackgroundTimeout is the duration to wait for background tasks (such as cache writes, etc) to complete.
	// ie, this is the amount of time we wait after the user's program execution finishes but before reflow exits.
	BackgroundTimeout time.Duration
}

type RunnerParams struct {
	RunConfig RunConfig
	Logger    *log.Logger

	// Status is the status object specific to a run.
	Status *status.Status
}

type RuntimeParams struct {

	// Config is the main configuration for the reflow runtime.
	Config infra.Config

	// Logger is the top-level logger passed to the various underlying components.
	// Logger is optional and overrides the Config provided logger (if any).
	Logger *log.Logger

	// Status is the top-level status object.  If provided, various internal components
	// will create groups under this status object for reporting purposes.
	Status *status.Status
}