rocket

type Blueprint struct {
	// Name of the blueprint.
	Name string `mapstructure:"name"`

	// Location is the location of the blueprint, set at read time
	Location string `mapstructure:"-"`

	// Description is a free text description of the blueprint
	Description string `mapstructure:"description"`

	// Location of runbook pro forma
	Runbook *Location `mapstructure:"runbook"`

	// Location of the mission
	Mission Location `mapstructure:"mission"`

	// Params is a list of parameters needed for the runbook.
	Params []Param `mapstructure:"params"`
}

type BlueprintInfo struct {
	// Name of the blueprint.
	Name string `mapstructure:"name"`

	// Version of the blueprint
	Version string `json:"version,omitempty" yaml:"version,omitempty" mapstructure:"version"`

	// Location is the location of the blueprint
	Location string `mapstructure:"location"`

	// Description is a free text description of the blueprint
	Description string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description"`
}

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

type ExecuteFunc = loggee.ActivityFunc

type Exports []string

type Filter struct {
	// IncludeOS is a list of operating systems to include.
	IncludeOS []string `mapstructure:"includeOS"`

	// IncludeArch is a list of architectures to permit.
	IncludeArch []string `mapstructure:"includeArch"`

	// ExcludeOS restricts an operating system from running.
	ExcludeOS []string `mapstructure:"excludeOS"`

	// ExcludeArch restricts specific architectures from running.
	ExcludeArch []string `mapstructure:"excludeArch"`

	// Skip prevents theactivity from running if true.
	Skip bool `mapstructure:"skip"`
}

type Getter interface {
	// Get a value
	Get(key string) string

	// All returns all the entries
	All() map[string]string
}

type Include struct {
	Path string `mapstructure:"path"`
	URL  string `mapstructure:"url"`
}

type InputSpec struct {
	// Variable name to import from.
	Variable string `mapstructure:"variable"`

	Inline string `mapstructure:"inline"`

	// Path provides the path to the input file.
	Path string `mapstructure:"path"`

	// URl provides a url to th input data.
	URL string `mapstructure:"url"`

	// Optional is true if resource can be missing.
	Optional bool `mapstructure:"optional"`

	// URLTimeout request timeout, default is 30 seconds.
	URLTimeout uint `mapstructure:"timeout"`

	// SkipExpand when true skips template expansion of the runbook.
	SkipExpand bool `mapstructure:"skipExpand"`
}

type Inventory struct {
	Items []string `mapstructure:"items"`
}

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

type Location struct {
	// Inline detail
	Inline string `mapstructure:"inline"`

	// Path provides the path to the item, relative to the blueprints location
	Path string `mapstructure:"path"`
}

type Mission struct {
	// Mission name, defaults to the config file name
	Name string `mapstructure:"name"`

	// Description is a free text description of the mission.
	Description string `mapstructure:"description"`

	// Additional contains any additional parameters specified in the
	// configuration.  They are included in the template data set
	// but will be overridden by any other duplicate keys
	Additional map[string]interface{} `mapstructure:",remain"`

	// BasicEnv is a map of additional environment variables
	// They are not template expanded
	BasicEnv VarMap `mapstructure:"basicEnv"`

	// Env is a map of additional environment variables
	// These are subject to template expansion after the params have been expanded
	Env VarMap `mapstructure:"env"`

	// Must is a slice of params that must be defined prior to the mission starting
	// Iif any are missing the mission will fail.
	Must MustHaveParams `mapstructure:"must"`

	// Params is a collection of parameters that can be used within
	// the child stages.  Parameters are template expanded and can use
	// Environment variables defined in Env
	Params Params `mapstructure:"params"`

	// Sequences specify a list of stages to run.
	// If no sequences are provides all stages are run in the order they are defined.
	// If sequences are included in the mission one must be specified or the mission will fail
	Sequences map[string][]string `mapstructure:"sequences"`

	// Stages represents the stages of the mission
	// If no sequences are included in the file all stages are executed in ordinal order.
	// If a sequence is included in the mission file the launch mission call must specify the sequence to use.
	Stages Stages `mapstructure:"stages"`

	// OnFail is a stage that is executed if the mission fails.
	OnFail *Stage `mapstructure:"onfail"`

	// Version of the mission definition
	Version string `mapstructure:"version"`
}

type MissionController interface {
	// Set option sets options on the mission controller
	SetOptions(options ...Option) error

	// RegisterTaskTypes we only want the best.
	RegisterTaskTypes(types ...TaskType)

	// LaunchMission loads and executes the mission
	// flightSequences may be specified, each sequence is run in the order specified.
	// Location is used to indicate where the config was read from, if blank the current working directory is assumed.
	LaunchMission(ctx context.Context, location string, spaceDust map[string]interface{}, flightSequences ...string) error

	LaunchMissionWithParams(ctx context.Context, location string,
		spaceDust map[string]interface{},
		params Params,
		flightSequences ...string) error

	// Assemble locates a blueprint from the assembly sources, loads the runbook and builds the assembly following the runbook.
	Assemble(ctx context.Context, blueprint string, sources []string, runbook string, params Params) error

	// GetRunbook gets the runbook for a blueprint
	GetRunbook(ctx context.Context, blueprintName string, sources []string) (string, error)

	// ListBlueprints builds a list of all blueprints found in the passed sources
	ListBlueprints(ctx context.Context, sources []string) ([]BlueprintInfo, error)

	ListTaskTypes(ctx context.Context) (TaskTypeInfoList, error)
}

type MustHaveParams []string

type OperationHandler func(next ExecuteFunc) ExecuteFunc

type Option interface {
	Name() string
}

type OutputSpec struct {
	// Variable is an exported variable available to later tasks in the same stage.
	Variable string `mapstructure:"variable"`

	// Output is a path to a file replacing STDOUT.
	Path string `mapstructure:"path"`

	// AppendOutput specifies if output should append.
	Append bool `mapstructure:"append"`

	// SkipExpand when true skips template expansion of the runbook.
	SkipExpand bool `mapstructure:"skipExpand"`

	// OS File permissions
	FileMode uint `mapstructure:"fileMode"`
}

type Param struct {
	// Name is the name of the parameter.
	// Name is mandatory.
	Name string `mapstructure:"name"`

	// Description is a free text description of the parameter.
	Description string `mapstructure:"description"`

	// Filter is an optional filter on the param.
	// If the param criteria are not met the param value will not be set.
	Filter *Filter `mapstructure:"filter"`

	// Optional if true allows the file not to exist.
	Optional bool `mapstructure:"optional"`

	// Path is the location of a resource that can provide the parameter's value.
	// Paths may be either a local file system path or a url to file or http(s) resource.
	// If both Path and Value are supplied the resource value will be appended to the Value.
	// Template expressions can be used in the path.  The template is expanded to get the
	// location of the resource.
	//
	// If the resource is successfully located it is appended to the Value property.
	// If SkipExpand is false the combined value will be processed as a template to
	// obtain the final value.   If SkipExpand is true the combined value will be used without
	// any additional expansion.
	Path string `mapstructure:"path"`

	// Print if true will display the value of the parameter once expanded to the log.
	Print bool `mapstructure:"print"`

	// SkipExpand skip templating the param.
	SkipExpand bool `mapstructure:"skipExpand"`

	// Value is the value of the parameter.  If SkipExpand is false the value will
	// be transformed using template expansion.
	Value string `mapstructure:"value"`
}

type Params []Param

type PreMission struct {
	Mission  map[string]interface{} `mapstructure:",remain"`
	Includes []Include              `mapstructure:"includes"`
}

type Redirection struct {
	// Input runbook
	Input *InputSpec `mapstructure:"input"`

	// Output runbook
	Output *OutputSpec `mapstructure:"output"`

	// Error runbook
	Error *OutputSpec `mapstructure:"error"`

	// MergeErrorWithOutput specifies if error output should go to outputt
	// if specified Error and AppendError are ignored
	MergeErrorWithOutput bool `mapstructure:"merge"`

	// LogOutput if true will cause output to be logged rather than going to go to std output.
	// If an output file is specified it will be used instead.
	LogOutput bool `mapstructure:"logStdOut"`

	// DirectError when true causes the commands std error output to go direct to running processes std error
	// When DirectError is false std error output is logged.
	DirectError bool `mapstructure:"directStdErr"`
}

type Runbook struct {
	// Name of the runbook.
	Name string `mapstructure:"name"`

	// Blueprint is the name of the blue print
	Blueprint string `mapstructure:"blueprint"`

	// Params is a list of parameters needed for the runbook.
	Params []Param `mapstructure:"params"`

	FlightSequence []string `mapstructure:"sequence"`
}

type Runtime struct {
	// GOOS is the operating system the host application is running against
	GOOS string
	// GOARCH is the architecture the host application is running against
	GOARCH string

	// UserName runtime username
	UserName string
}

type Stage struct {
	// Name of the stage.
	// If it is not provided it default to the ordinal ID of the stage within the mission
	Name string `mapstructure:"name"`

	// Stage is impmented by another named stage.
	Ref string `mapstructure:"ref"`

	// Description is a free text description of the stage.
	Description string `mapstructure:"description"`

	// BasicEnv is a map of additional environment variables
	// They are not template expanded
	BasicEnv VarMap `mapstructure:"basicEnv"`

	// If is evaluated prior to running a stage.  If the condition template expression evaluates to true/yes/1 the
	// stage will be run.  If the template is blank or non true value the stage will not be run and the step will be skipped.
	If string `mapstructure:"if"`

	// Dir is the directory to execute the stage in.
	Dir string `mapstructure:"dir"`

	// Env is a map of additional environment variables
	// These are subject to template expansion after the params have been expanded.
	Env VarMap `mapstructure:"env"`

	// Filter is an optional filter on the stage.
	// If the filter criteria are not met the stage will not be executed.
	Filter *Filter `mapstructure:"filter"`

	// Must is a slice of params that must be defined prior to the stage starting
	// Iif any are missing the mission will fail.
	Must MustHaveParams `mapstructure:"must"`

	// NoTrust indicates the stage should not inherit environment
	// variables or parameters from its parent.  This can be used with a run stage
	// where you do not want the process to receive API tokens etc.
	NoTrust bool `mapstructure:"noTrust"`

	// OnFail is a task that is executed if the stage fails.
	OnFail *Task `mapstructure:"onfail"`

	// Params is a collection of parameters that can be used within
	// the child stages.  Parameters are template expanded and can use
	// Environment variables defined in Env
	Params Params `mapstructure:"params"`

	// Tasks is a collection of one or more tasks to execute
	// Tasks are executed sequentially
	Tasks Tasks `mapstructure:"tasks"`
}

type StageMap map[string]Stage

type Stages []Stage

type Task struct {
	// Name of the task.
	// If it is not provided it default to the ordinal ID of the task within the stage
	Name string `mapstructure:"name"`

	// Task is impmented by another named task in the same stage.
	Ref string `mapstructure:"ref"`

	// BasicEnv is a map of additional environment variables.
	// They are not template expanded.
	BasicEnv VarMap `mapstructure:"basicEnv"`

	// Concurrent is a list of tasks to execute concurrently.
	Concurrent Tasks `mapstructure:"concurrent"`

	// If is evaluated prior to running a task.  If the condition template expression evaluates to true/yes/1 the
	// task will be run.  If the template is blank or non true value the task will not be run and the step will be skipped.
	If string `mapstructure:"if"`

	// Description is a free text description of the task.
	Description string `mapstructure:"description"`

	// Definition contains the additional data required to process the task type
	Definition map[string]interface{} `mapstructure:",remain"`

	// Env is a map of additional environment variables.
	// These are subject to template expansion after the params have been expanded.
	Env VarMap `mapstructure:"env"`

	// Export is a list of variables to export. This list can be used by try and group task types
	// to export their variables (output from sub tasks) to their parent stage or task.
	Export Exports `mapstructure:"export"`

	// Filter is an optional filter on the task.
	// If the filter criteria are not met the task will not be executed.
	Filter *Filter `mapstructure:"filter"`

	// Try is a list of tasks to try.
	Group Tasks `mapstructure:"group"`

	// Must is a slice of params that must be defined prior to the task starting
	// Iif any are missing the mission will fail.
	Must MustHaveParams `mapstructure:"must"`

	// NoTrust indicates the task should not inherit environment
	// variables or parameters from the parent.  This can be used with a run task
	// where you do not want the process to receive API tokens etc.
	NoTrust bool `mapstructure:"noTrust"`

	// OnFail is a task that is executed if the stage fails.
	OnFail *Task `mapstructure:"onfail"`

	// Params is a collection of parameters that can be used within
	// the child stages.  Parameters are template expanded and can use
	// Environment variables defined in Env.
	// Params and Env variables are template expanded during the preparation phase of a mission.  That means their
	// values are calculated prior to any task running in any stage.
	// If values need to be calculated before or after a run use pre or post variaBLES
	Params Params `mapstructure:"params"`

	// PostVars are variable evaluated after a task has run
	// Post variable are automatically exported to the parent task/stage.
	PostVars VarMap `mapstructure:"postvars"`

	// PreVars are variables calculated immediately prior to a run.  They are are not exported to the parent context.
	// If the variable needs to be used by other tasks it should be explicitly exported (See Export above).
	PreVars VarMap `mapstructure:"prevars"`

	// Try is a list of tasks to try.
	Try Tasks `mapstructure:"try"`

	// Type is the type of the task.  The task type must have been registered
	// with the mission control.  Tasks not registered will fail the mission.
	Type string `mapstructure:"type"`
}

type TaskMap map[string]Task

type TaskType interface {

	// Type of the task.
	Type() string

	// Description is a free text description of the type
	Description() string

	// Prepare the task from the input details.
	Prepare(ctx context.Context, capComm *CapComm, task Task) (ExecuteFunc, error)
}

type TaskTypeInfo struct {
	// Type of task.
	Type string `mapstructure:"name"`

	// Description is a free text description of the task
	Description string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description"`
}

type TaskTypeInfoList []TaskTypeInfo

type Tasks []Task

type TemplateData map[string]interface{}

type VarMap map[string]string