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 Delims struct {
	// Left is the opening delimiter
	Left string `mapstructure:"left"`

	// Right is the closing delimiter
	Right string `mapstructure:"right"`
}

type EnvMap map[string]string

type ExecuteFunc = loggee.ActivityFunc

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, defsaults to the config file name
	Name string `mapstructure:"name"`

	// 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 EnvMap `mapstructure:"basicEnv"`

	// Env is a map of additional environment variables
	// These are subject to template expansion after the params have been expanded
	Env EnvMap `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 []Param `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 []Stage `mapstructure:"stages"`

	// 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 []Param,
		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, specLocation string, params []Param) 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)
}

type MustHaveParams []string

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"`

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

	// 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"`

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

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

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

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"`

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

	// 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 EnvMap `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"`

	// 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"`

	// 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"`

	// 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 []Param `mapstructure:"params"`

	// Tasks is a collection of one or more tasks to complete
	// Tasks are executed sequentally
	Tasks []Task `mapstructure:"tasks"`

	// Try to run the stage but if it fails do no abort the whole run
	Try bool `mapstructure:"try"`
}

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

	// 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"`

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

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

	// Dir is the directory to execute the task 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 EnvMap `mapstructure:"env"`

	// 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"`

	// 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"`

	// 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"`

	// 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 []Param `mapstructure:"params"`

	// Try to run the task but if it fails do no abort the whole run
	Try bool `mapstructure:"try"`
}

type TaskType interface {

	// Type of the task
	Type() string

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

type TemplateData map[string]interface{}