task

type Executor interface {
	Execute() (err error)
}

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

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

type MetaTaskAction string

type MetaTaskIdentity struct {
	// Identity provides a unique identification to this
	// task.
	//
	// NOTE:
	//  Usage: There should not be two tasks with same identity
	// in a cas template engine run.
	Identity string `json:"id"`
	// Kind of the task
	Kind string `json:"kind"`
	// APIVersion of the task
	APIVersion string `json:"apiVersion"`
}

type MetaTaskProps struct {
	// RunNamespace is the namespace where task will get
	// executed
	RunNamespace string `json:"runNamespace"`

	// Owner represents the owner of this task
	Owner string `json:"owner"`

	// ObjectName is the name of the resource that gets
	// created or will get operated by this task
	ObjectName string `json:"objectName"`

	// Options is a set of selectors that can be used for
	// tasks that are get or list based actions
	Options string `json:"options"`

	// Retry specifies the no. of times this particular task (i.e. all properties
	// remains same) can be re-tried. This is typically used along with task
	// result verify options for get or list related actions.
	//
	// A sample retry option:
	//
	// # max of 10 attempts in 20 seconds interval
	// retry: "10,20s"
	Retry string `json:"retry"`

	// Disable will disable execution of this task
	Disable bool `json:"disable"`
}

type MetaTaskSpec struct {
	// MetaTaskIdentity provides the identity to this task
	MetaTaskIdentity
	// MetaTaskProps provides the task's meta related properties
	MetaTaskProps
	// Action representing this task
	//
	// e.g. get based task or list based task or put based task and so on
	Action MetaTaskAction `json:"action"`
	// RepeatWith sets one or more resources for repetitive execution.
	// In other words a task template is executed multiple times based on each
	// of the item present here.
	RepeatWith RepeatWithResource `json:"repeatWith"`
}

type OutputExecutor interface {
	Output() (output []byte, err error)
}

type PostTaskRunFn func(taskResult map[string]interface{})

type RepeatWithResource struct {
	// resources is a list of resources that will drive the repetition logic
	// of task execution
	//
	// NOTE:
	//  This is typically a set of items which does not belong to MetaTask
	// category. Any random list of items that influences the repetition logic
	// should be set here.
	Resources []string `json:"resources"`
	// metas is a list of meta task info that will drive the repetition logic
	// of task execution
	Metas []MetaTaskProps `json:"metas"`
}

type RunOptions struct {
	TaskGroupRunner
	// contains filtered or unexported fields
}

type RunOptionsMiddleware func(given *RunOptions) (updated *RunOptions, err error)

type RunTaskKind string

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

type TaskPatch struct {
	// Type determines the type of patch to be applied
	Type TaskPatchType `json:"type"`
	// Specs is a yaml document that provides the patch specifications
	//
	//  Below is a sample patch as yaml document
	//  “`yaml
	//      spec:
	//        template:
	//          spec:
	//            affinity:
	//              nodeAffinity:
	//                requiredDuringSchedulingIgnoredDuringExecution:
	//                  nodeSelectorTerms:
	//                  - matchExpressions:
	//                    - key: kubernetes.io/hostname
	//                      operator: In
	//                      values:
	//                      - amit-thinkpad-l470
	//              podAntiAffinity: null
	//  “`
	Specs string `json:"pspec"`
}

type TaskPatchType string

type TaskSpecFetcher interface {
	Fetch(taskName string) (runtask *v1alpha1.RunTask, err error)
}