metafora

type Balancer interface {
	// Init is called once and only once before any other Balancer methods are
	// called. The context argument is meant to expose functionality that might
	// be useful for CanClaim and Balance implementations.
	Init(BalancerContext)

	// CanClaim should return true if the consumer should accept a task.
	//
	// When denying a claim by returning false, CanClaim should return the time
	// at which to reconsider the task for claiming.
	CanClaim(task Task) (ignoreUntil time.Time, claim bool)

	// Balance should return the list of Task IDs that should be released. The
	// criteria used to determine which tasks should be released is left up to
	// the implementation.
	Balance() (release []string)
}

type BalancerContext interface {
	// Tasks returns a sorted list of task IDs owned by this Consumer. The
	// Consumer stops task manipulations during claiming and balancing, so the
	// list will be accurate unless a task naturally completes.
	Tasks() []RunningTask
}

type Client interface {
	// SubmitTask submits a task to the system, the task id must be unique.
	SubmitTask(Task) error

	// Delete a task
	DeleteTask(taskId string) error

	// SubmitCommand submits a command to a particular node.
	SubmitCommand(node string, command Command) error

	// Nodes retrieves the current set of registered nodes.
	Nodes() ([]string, error)
}

type ClusterState interface {
	// Provide the current number of jobs
	NodeTaskCount() (map[string]int, error)
}

type Command interface {
	// Name returns the name of the command.
	Name() string

	// Parameters returns the parameters, if any, the command will be executed
	// with.
	Parameters() map[string]interface{}

	// Marshal turns a command into its wire representation.
	Marshal() ([]byte, error)
}

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

type Coordinator interface {
	// Init is called once by the consumer to provide a Logger to Coordinator
	// implementations. NewConsumer will return Init's return value.
	Init(CoordinatorContext) error

	// Watch the broker for claimable tasks. Watch blocks until Close is called
	// or it encounters an error. Tasks are sent to consumer via the tasks chan.
	Watch(tasks chan<- Task) (err error)

	// Claim is called by the Consumer when a Balancer has determined that a task
	// ID can be claimed. Claim returns false if another consumer has already
	// claimed the ID.
	Claim(Task) bool

	// Release a task for other consumers to claim. May be called after Close.
	Release(Task)

	// Done is called by Metafora when a task has been completed and should never
	// be scheduled to run again (in other words: deleted from the broker).
	//
	// May be called after Close.
	Done(Task)

	// Command blocks until a command for this node is received from the broker
	// by the coordinator. Command must return (nil, nil) when Close is called.
	Command() (Command, error)

	// Close the coordinator. Stop waiting for tasks and commands. Remove node from broker.
	//
	// Do not release tasks. The consumer will handle task releasing.
	Close()

	// Name of the coordinator for use in logs and other tooling.
	Name() string
}

type CoordinatorContext interface {
	// Lost is called by the Coordinator when a claimed task is lost to another
	// node. The Consumer will stop the task locally.
	//
	// Since this implies there is a window of time where the task is executing
	// more than once, this is a sign of an unhealthy cluster.
	Lost(Task)
}

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

type Handler interface {
	// Run handles a task and blocks until completion or Stop is called.
	//
	// If Run returns true, Metafora will mark the task as Done via the
	// Coordinator. The task will not be rescheduled.
	//
	// If Run returns false, Metafora will Release the task via the Coordinator.
	// The task will be scheduled to run again.
	//
	// Panics are treated the same as returning true.
	Run() (done bool)

	// Stop signals to the handler to shutdown gracefully. Stop implementations
	// should not block until Run exits.
	//
	// Stop may be called more than once but calls are serialized. Implmentations
	// may perform different operations on subsequent calls to Stop to implement
	// graceful vs. forced shutdown conditions.
	//
	// Run probably wants to return false when stop is called, but this is left
	// up to the implementation as races between Run finishing and Stop being
	// called can happen.
	Stop()
}

type HandlerFunc func(Task) Handler

type LogOutputter interface {
	Output(calldepth int, s string) error
}

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

type ResourceReporter interface {
	// Used returns the amount of a resource used and the total amount of that
	// resource.
	Used() (used uint64, total uint64)

	// String returns the unit resources are reported in.
	String() string
}

type RunningTask interface {
	Task() Task

	// Started is the time the task was started by this consumer.
	Started() time.Time

	// Stopped is the first time Stop() was called on this task or zero is it has
	// yet to be called. Tasks may take an indeterminate amount of time to
	// shutdown after Stop() is called.
	Stopped() time.Time

	// Handler implementation called for this task.
	Handler() Handler
}

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

type Task interface {
	// ID is the immutable globally unique ID for this task.
	ID() string
}