occamy

type BasicError string

type DetailedError struct {
	BasicErr BasicError
	Cause    string
}

type ErrorMonitor interface {
	RecordError(err error)
}

type Handler func(header Headers, body []byte) (Task, error)

type Headers map[string]interface{}

type LatencyMonitor interface {
	RecordProcessDuration(process string, duration time.Duration)
	RecordTaskDuration(group string, status SlotStatus, duration time.Duration)
}

type Message interface {
	// Body must return the body of the message.
	Body() []byte

	// Headers must return the headers of the message.
	Headers() Headers

	// Ack must acknowledge the messages as successfully handled and does not
	// need to be passed to another server.
	Ack() error

	// Reject must negative acknowledge the message as uncompleted. The requeue
	// parameter will determine if the message should be requeued and passed to
	// another server.
	//
	// For example, if a server shuts down the task associated with a message
	// will not be completed and will be passed to another server. On the other
	// hand if
	Reject(requeue bool) error
}

type Monitors struct {
	Error    ErrorMonitor
	Latency  LatencyMonitor
	Resource ResourceMonitor
}

type NopErrorMonitor struct{}

type NopLatencyMonitor struct{}

type NopResourceMonitor struct{}

type ResourceMonitor interface {
	RecordTaskStarting(group string, status SlotStatus)
	RecordTaskStopping(group string, status SlotStatus)
}

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

type ServerConfig struct {
	// Slots sets how many slots will be crated i.e. the maximum number of
	// simultaneous tasks allowed.
	Slots int

	// ExpansionSlotBuffer sets how many
	ExpansionSlotBuffer int

	// ExpansionPeriod sets how often the expansion process will be run. A value
	// of zero or less will mean that the expansion process will never be run.
	ExpansionPeriod time.Duration

	// KillTimeout sets the maximum duration allowed for task a task to be
	// killed in. This is important to set for allowing unprotected tasks
	// to be killed and replaced by protected ones.
	KillTimeout time.Duration

	// HeaderKeyTaskID sets the header key used to obtain the task ID for any
	// control message received. In other words the value in the header
	// corresponding to this key will be treated as the task ID.
	HeaderKeyTaskID string

	Handler Handler

	Monitors Monitors
}

type SlotStatus string

type Task interface {
	// Do should perform the task and if a failure is encountered
	// one of the custom occamy errors should be returned.
	//
	// If the context provided is canceled the process must be stopped
	// immediately and ungracefully, and return the error
	// `ErrTaskInterrupted` which will cause the task to be run on
	// another server.
	Do(ctx context.Context) error

	Details() TaskDetails

	// Expand creates additional tasks. These tasks will be unprotected
	// and maybe cancelled at anytime.
	Expand(n int) []Task

	// Handle handles a control message. The error return should be
	// one of the custom occamy errors.
	Handle(ctx context.Context, headers Headers, body []byte) error
}

type TaskDetails struct {
	// Deadline is the deadline of the task, if it is known,
	// and is only relevant for tasks that that arrived via
	// the control channel.
	Deadline time.Time

	// The ID of the the task. Any control messages
	// for this task must have this ID included in the header.
	ID string

	// Group denotes the general group that task this belongs to. This
	// is used for monitoring usage.
	Group string
}

type WrappedError struct {
	BasicErr BasicError
	InnerErr error
}