work

type BaseFilter struct {
	// States returns objects that are currently at one the "states".
	// If empty, all states are included.
	States []State
}

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

type Hub struct {

	// Signal provides access to signalling methods.
	Signal chan SignalMsg
	// contains filtered or unexported fields
}

type Job struct {
	*Hub

	Meta

	// CogPath is the name of the Cog the Job will use.
	CogPath string

	// Args are the arguments to the Cog.
	Args string

	// ArgsType is the encoding method for the Args.
	ArgsType pb.ArgsType

	// Output is the output from the Cog.
	Output string

	// Timeout is the amount of time a Job is allowed to run.
	Timeout time.Duration

	// Retries is the number of times to retry a Cog that fails.
	Retries int

	// RetryDelay is how long to wait between retrying a Cog.
	RetryDelay time.Duration

	// RealUser is the username of user Submitting the Labor to Marmot.
	RealUser string
	// contains filtered or unexported fields
}

type Labor struct {
	*Hub

	Meta

	// ClientID is a unique ID sent by the client.
	ClientID string

	// Tags are single word text strings that can be used to group Labors when
	// doing a search.
	Tags []string

	// Tasks are the tasks that are associated with this Labor.
	Tasks []*Task

	// Completed is closed when the Labor has finished execution.
	Completed chan bool
	// contains filtered or unexported fields
}

type LaborFilter struct {
	BaseFilter

	// NamePrefix locates Labors starting with the string.
	// NameSuffix locates Labors ending with the string.
	NamePrefix, NameSuffix string

	// Tags matches any Labor that has any tag listed.
	Tags []string

	// SubmitBegin includes only Labors that were submitted at or after
	// SubmitBegin.
	// SubmitEnd will only include an object which was submitted before SubmitEnd.
	SubmitBegin, SubmitEnd time.Time
}

type Meta struct {
	// ID contains a unique UUIDv4 representing the object.
	ID string

	// Name contains the name to be displayed to users.
	Name string

	// Desc contains a description of what the object is doing.
	Desc string

	// Started is when an object begins execution.
	Started time.Time

	// Ended is when an object stops execution.
	Ended time.Time

	// Submitted is when a Labor was submitted to the system.  Only valid for Labors.
	Submitted time.Time
	// contains filtered or unexported fields
}

type Read interface {
	// Labor reads a Labor from storage.  If full==false, it only returns the
	// Labor data itself and none of the sub-containers.
	RLabor(ctx context.Context, id string, full bool) (*Labor, error)

	// Task reads a Task from storage. This only returns the Task data.
	RTask(ctx context.Context, id string) (*Task, error)

	// Sequence reads a Sequence from storage.  It only returns the Sequence
	// data and non of the sub-containers.
	RSequence(ctx context.Context, id string) (*Sequence, error)

	// Job reads a Job from storage.  If full==false, it will not return the
	// Job.Args or Job.Output.
	RJob(ctx context.Context, id string, full bool) (*Job, error)
}

type Reason int

type Search interface {
	// Labors streams a time ordered stream of Labors matching the filter.
	// They are ordered from earliest submitted.  They do not contain data.
	Labors(ctx context.Context, filter LaborFilter) (chan SearchResult, error)
}

type SearchResult struct {
	// Labor is the found Labor.
	Labor *Labor

	// Error indicates the stream had an error.
	Error error
}

type Sequence struct {
	*Hub
	Meta

	// Target is the name of what this sequence targets. This could be a device,
	// a service, a directory... whatever makes sense for whatever is being done.
	Target string

	// Jobs is a sequence of jobs to execute.
	Jobs []*Job
	// contains filtered or unexported fields
}

type Signal int

type SignalMsg struct {
	// Signal is the signal type you are sending.
	Signal Signal

	// Ack is closed when the sub-object has finished its signal processing.
	Ack chan bool
}

type State int

type Storage interface {
	Read
	Write
	Search
}

type Task struct {
	*Hub
	Meta

	// PreChecks are Jobs that are executed before executing the Jobs in the
	// Task. If any of these fail, the Task is not executed and fails.
	// This is used provide checks before initiating actions. These are run
	// concurrently.
	PreChecks []*Job

	// ContChecks are Jobs that are exeucted continuously until the task ends
	// with ContCheckInterval between runs.  If any check fails, the Task stops
	// execution and fails.  These are run concurrently.
	ContChecks []*Job

	// ToleratedFailures is how many failures to tolerate before stopping.
	ToleratedFailures int

	// Concurrency is how many Jobs to run simultaneously.
	Concurrency int

	// ContCheckInterval is how long between runs of ContCheck Jobs.
	ContCheckInterval time.Duration

	// PassFailures causes the failures in this Task to be passed to the next
	// Task, acting againsts its ToleratedFailures.
	PassFailures bool

	// Sequence are a set of Jobs.
	Sequences []*Sequence
	// contains filtered or unexported fields
}

type Write interface {
	// Labor writes the Labor and sub-containers to storage.
	// This should only be used either on ingest of a Labor or during a
	// recovery of a Labor.
	WLabor(ctx context.Context, l *Labor) error

	// WLaborState allows updating of the Labor's State and Reason.
	WLaborState(ctx context.Context, l *Labor) error

	// Task writes out a Task to storage.  This only writes the Task data, none
	// of the sub-containers.
	WTask(ctx context.Context, t *Task) error

	// Sequence writes out a Sequence to storage.  This only writes the Sequence
	// data, none of the sub-containers.
	WSequence(ctx context.Context, s *Sequence) error

	// Job writes out a Job to storage.  This only writes the Job data.  It does
	// not write the Job.Args, as they should only be recorded once by a call to
	// Write.Labor().
	WJob(ctx context.Context, j *Job) error
}