fnfile

type CallInfoOption func(options *CallInfoOptions)

type CallInfoOptions struct {
	Clock timejumper.Clock
	In    io.Reader
}

type CheckSumAlgorithm string

type DeferSpec struct {
	StepMeta
	Do
}

type DiscardResponseWriter struct {
	ResponseWriter
}

type Do struct {
	StepMeta
	Steps Steps `json:"steps"`
}

type Duration time.Duration

type Dynamic struct {
	StepMeta
	JSON string `json:"json,omitempty"`
}

type Features struct {
}

type FileCondition struct {
	IfSpec

	// Sources matched files have their contents hashed.
	// If the content hashes change between runs, this fn will be marked as "out-of-date".
	Sources FileGlobs `json:"from,omitempty"`

	// Generates matched files are checked to exist.
	// If these files do not exist, this fn will be marked as "out-of-date".
	// When providing a glob, only 1 match is required to keep this fn "up-to-date".
	Generates FileGlobs `json:"makes,omitempty"`
}

type FileGlobs []string

type Fn struct {
	StepMeta
	Run string `json:"run,omitempty"`
}

type FnCondition struct {
	IfSpec

	Fn string `json:"fn"`
}

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

type FnDef struct {
	Name string `json:"-"`

	Run RunOption `json:"run,omitempty"`

	// Inputs are parameters for this FnDef, used when called by another FnDef.
	Inputs Inputs `json:"inputs,omitempty"`

	// Locals are values only available inside this fn via contexts.Locals
	Locals Vars `json:"locals,omitempty"`

	// Outputs are values that are available via contexts.Fn
	Outputs Vars `json:"outputs,omitempty"`

	// Short is the short description shown in the 'help' output.
	Short string `json:"short,omitempty"`

	// Long is the long message shown in the 'help <this-fn>' output.
	Long string `json:"long,omitempty"`

	// Example is examples of how to use the fn.
	Example string `json:"example,omitempty"`

	// Do are steps that run serially
	Do Do `json:"do,omitempty"`

	// Dir is the directory in which steps will be executed from (default: fnfile.yml directory)
	// This dir is available as a context to sub steps, and thus, those steps can use it to make decisions,
	// if specifying their own directory as relative, it will be relative to this.
	Dir string `json:"dir,omitempty"`

	// Env is a map of environment variables that are available to all steps in the fn.
	// You can also set environment variables for the entire fnfile or an individual step.
	//
	// When more than one environment variable is defined with the same name (in different locations),
	// FnDef uses the most specific environment variable.
	//
	// For example, an environment variable defined in a step will override fn and global (fnfile) variables
	// with the same name, while the step executes.
	// An environment variable defined for a fn will override a global (fnfile) variable
	// with the same name, while the fn executes.
	Env Vars `json:"env,omitempty"`

	// SerialGroups is an array of arbitrary label-like strings. Executions of this fn
	// and other fns referencing the same tags will be serialized.
	SerialGroups SerialGroups `json:"serialGroups,omitempty"`

	// Matrix is a step/fn hook to define a matrix of step/fn configurations.
	//
	// A matrix allows you to create multiple steps/fns by performing variable substitution
	// in a single step/fn definition.
	//
	// When defined on a fn, it dynamically creates several fns, suffixing the fn name with the matrix values.
	//
	// Each individual fn can be called. The original fn becomes a "virtual fn" that "needs" the matrix of fns.
	// Allowing you to call all matrix fns from the single "parent" virtual fn.
	//
	// For example, you can use a matrix to create fns for more than one supported version of a programming language,
	// variable values, or tool, etc. A matrix reuses the step/fn's configuration
	// and creates a step/fn for each matrix you configure.
	//
	// Example
	//
	//	fns:
	//	  echo:
	//		matrix:
	//		- env: ["dev", "staging", "prod"]
	//		steps:
	//		- run: "echo {{.Matrix.env}}"
	//
	// fns defined are:
	//  echo
	//  echo:dev
	//  echo:staging
	//  echo:prod
	Matrix Matrix `json:"matrix,omitempty"`

	// Timeout is the bounding time limit (duration) for the fn before signaling for termination via SIGINT.
	Timeout Duration `json:"Timeout,omitempty"`
}

type FnDefs map[string]FnDef

type FnFile struct {
	// Version is the version of the Fn schema
	// It is the first thing that is parsed by Task in order to inform how the rest of the file should be parsed.
	Version string `json:"version,omitempty"`

	// Features are flags for fn
	// It enables users to change the behavior of fn by enabling/disabling features of the engine
	Features Features `json:"features,omitempty"`

	// Globals are variables that are available from any fn
	Globals Vars `json:"globals,omitempty"`

	// Includes allows other Fnfiles to be included in this one. Each other include is becomes "namespaced".
	// More on namespacing later...
	Includes Includes `json:"includes,omitempty"`

	// Def is a set of function definitions
	Fns FnDefs `json:"fns,omitempty"`
}

type Fns []Fn

type Gen struct {
	Files FileGlobs `json:"files"`
}

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

type IfSpec struct {
	StepMeta
}

type Include struct {
	Filename  string `json:"filename"`
	Checksum  string `json:"checksum"`
	Algorithm string `json:"algorithm"`
	// Always, IfNotPresent, Never
	PullPolicy  PullPolicy `json:"pullPolicy"`
	PullTimeout Duration   `json:"pullTimeout"`
	Namespace   string     `json:"namespace"`
}

type Includes []Include

type Input struct {
	Name        string `json:"-"`
	Description string `json:"description,omitempty"`
	Required    bool   `json:"required,omitempty"`
	Default     string `json:"default,omitempty"`
}

type Inputs map[string]Input

type KeyValues map[string]set.Set[string]

type Matrix struct {
	StepMeta

	KVs KeyValues `json:"kvs,omitempty"`

	// Include enables different matrix "shapes" aside from the expected NxM table produced from KVs.
	// Each key:value pair will be added to each of the matrix combinations, but only if the keys are unique (not part of the original matrix).
	// For any unoriginal keys, new matrix combinations will be created.
	Include KeyValues `json:"include,omitempty"`
}

type Parallel struct {
	StepMeta

	Steps    Steps `json:"steps"`
	FailFast bool  `json:"failFast,omitempty"`
	Limit    int   `json:"limit,omitempty"`
}

type Param Variable

type Params map[string]Param

type PullPolicy string

type ResponseWriter interface {
	Defer(StepHandler)
	OutWriter() io.Writer
	ErrOutWriter() io.Writer
	Error(error)
	ErrorOrNil() error
}

type ReturnSpec struct {
	StepMeta
}

type RunOption string

type SerialGroups []string

type Sh struct {
	StepMeta
	// Run defines a shell command.
	Run string `json:"run,omitempty"`
	// Dir is the desired working directory in which this command should execute in.
	Dir string `json:"dir,omitempty"`
}

type Src struct {
	Files FileGlobs `json:"files"`
}

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

type Step interface {
	Handle(w ResponseWriter, c *FnContext)
}

type StepHandler interface {
	Handle(w ResponseWriter, c *FnContext)
}

type StepHandlerFunc func(w ResponseWriter, c *FnContext)

type StepMeta struct {
	// Name is the user defined name of the step. Defaults to "anonymous"
	Name string `json:"-"`
	// Locals are variables available to this step and all child steps (like a closure)
	Locals Vars `json:"vars,omitempty"`
	// Timeout is the bounding time limit (duration) for  before signaling for termination
	Timeout Duration `json:"timeout,omitempty"`
}

type StepName string

type StepOutcomeCondition struct {
	IfSpec
}

type StepUnmarshaller func(data []byte) (Step, error)

type StepVisitor struct {
	VisitDefer    func(d DeferSpec)
	VisitDo       func(do Do)
	VisitFnStep   func(fn Fn)
	VisitMatrix   func(m Matrix)
	VisitParallel func(p Parallel)
	VisitReturn   func(r ReturnSpec)
	VisitSh       func(sh Sh)
}

type Steps []Step

type ThreadSafeMultiError struct {
	*multierror.Error
	// contains filtered or unexported fields
}

type Variable struct {
	Name   string `json:"-"`
	Static string `json:"static,omitempty"`
	Tpl    string `json:"tpl,omitempty"`
	Sh     Sh     `json:"sh,omitempty"`
}

type Vars map[string]Variable