tasks

type AnnounceResponse struct {
	// NodeID is the NodeID of the distributor.
	NodeID pyme.NodeID `json:"nodeID"`
}

type Calculator interface {
	// Calculate estimates the execution cost of a task.
	Calculate(Task) (float64, error)

	// TaskType returns the TaskType this calculator is responsible for.
	TaskType() TaskType
}

type Endpoint struct {
	// IP is the IP of the machine.
	IP net.IP
	// Port is the TCP port of the endpoint.
	Port uint16
}

type ExecutionStatus string

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

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

type Method struct {
	// HTTPMethod is the HTTP method (verb) for the method.
	HTTPMethod string
	// Path is the HTTP path for the method.
	Path string
}

type NodeServer interface {
	// GetTasks gets up to numWant task to be executed by a worker.
	// numWant <= 0 defaults to one task.
	GetTasks(id WorkerID, numWant int) ([]Task, error)

	// HandIn notifies the task server that the execution of the task with
	// the given TaskID is finished.
	// If the ExecutionStatus is Success, the task has been completed and
	// all results have been submitted.
	// If the ExecutionStatus is Failure, the task server can decide whether
	// to report the failure to the node that assigned the task or whether
	// to try executing it again on a local worker.
	HandIn(TaskID, ExecutionStatus) error

	// RateTask rates the given task for this node.
	// Rating must assign a value in [0,1] for each resource necessary
	// to complete the task. The rating for the complete task must be in
	// [0,n] for n resources required to execute the task or -1.
	// A rating of -1 indicates that this node does not rate tasks at the
	// moment and rating should be done on the distributor instead.
	RateTask(Task) (TaskRating, error)

	// Stop stops the NodeServer.
	// This will stop any open requests for GetTask and will stop announcing
	// regularly to its Distributors. They will register the node as being
	// inactive and redistribute tasks given to it.
	Stop()
}

type NodeStatistics struct {
	// TasksAccepted is the number of tasks the node has received as a
	// result of calling GetTasks.
	TasksAccepted uint64 `json:"tasksAccepted"`

	// TasksCompleted is the number of tasks the node has reported as
	// executed successfully.
	TasksCompleted uint64 `json:"tasksCompleted"`

	// TasksCompleted is the number of tasks the node has reported as
	// failed.
	TasksFailed uint64 `json:"tasksFailed"`

	// TasksCompleted is the sum of the number of tasks the node has
	// reported as not executed and tasks that were withdrawn from a node
	// as a result of the node timing out.
	TasksNotExecuted uint64 `json:"tasksNotExecuted"`
}

type QueueStatistics struct {
	// TasksPosted is the number of tasks posted to the queue.
	TasksPosted uint64 `json:"tasksPosted"`

	// TasksRunning is the number of tasks that have been rated and
	// assigned to a node.
	TasksRunning uint64 `json:"tasksRunning"`

	// TasksCompleted is the number of tasks that have completed
	// successfully.
	TasksCompleted uint64 `json:"tasksCompleted"`

	// TasksFailed is the number of tasks that have failed.
	TasksFailed uint64 `json:"tasksFailed"`

	// AverageExecutionCost is the average execution cost of a task in this
	// queue, determined by the execution cost known at the time of
	// assigning the task to a node.
	AverageExecutionCost float64 `json:"averageExecutionCost"`
}

type Rater interface {
	// Rate estimates the cost of fetching or storing the resource identified
	// by URI.
	Rate(URI *url.URL) (float64, error)

	// Scheme returns the URI scheme this rater is responsible for.
	Scheme() string
}

type SerializableHandInEntry struct {
	// TaskID is the TaskID of the referenced Task.
	TaskID TaskID `json:"taskID"`

	// ExecutionStatus
	ExecutionStatus string `json:"status"`
}

type Task struct {
	// ID identifies the task uniquely.
	ID TaskID `json:"id"`

	// Type determines the type of the task.
	Type TaskType `json:"type"`

	// Taskdef is the definition of a task.
	// It must not be present if TaskdefRef is not empty.
	Taskdef map[string]string `json:"taskdef,omitempty"`

	// TaskdefRef references the task definition through a resource URI.
	// It must not be present if Taskdef is not nil.
	TaskdefRef string `json:"taskdefRef,omitempty"`

	// Inputs describes how to obtain input data.
	Inputs map[string]string `json:"inputs"`

	// Outputs describes how to store results.
	Outputs map[string]string `json:"outputs"`
}

type TaskDistributor interface {
	// PostTask adds the given task to the set of tasks to be processed.
	// The task will be assigned to a node based on the location of the data
	// needed to process the task.
	// The ID of the given task needs to consist only of the unique
	// identifier within the queue. The queue name and distributor node's ID
	// will be prepended by the distributor.
	// This is typically called from the analysis software.
	PostTask(queue string, task Task) error

	// GetTasks gets up to numWant tasks to be executed on the node identified
	// by nodeID.
	// The call blocks until tasks are available or timeout has elapsed.
	// It is not guaranteed that numWant tasks will be returned. The task
	// server may (and should!) hold tasks for a node in a queue and can
	// return multiple tasks at once.
	// A task server is allowed to request more tasks than it immediately
	// needs, i.e. more tasks than it has workers to give them to. If the
	// task server shuts down or otherwise stops executing tasks, it must
	// report tasks not executed to the node that reported them with an
	// ExecutionStatus of NotExecuted.
	GetTasks(nodeID pyme.NodeID, numWant int, timeout time.Duration) ([]Task, error)

	// HandIn notifies the task server of the ExecutionStatus of the task
	// identified by the given TaskID.
	// If the ExecutionStatus is Success, the task has been completed and
	// all results have been submitted.
	// If the ExecutionStatus is NotExecuted, the task has not been
	// attempted to execute and must be redistributed to the cluster.
	// Including the NodeID prevents nodes from wrongfully handing in tasks
	// for another node.
	HandIn(pyme.NodeID, TaskID, ExecutionStatus) error

	// QueueStatistics returns statistics about queues running on the
	// Distributor.
	QueueStatistics() map[string]QueueStatistics

	// Announce announces the endpoint of a local node server to a
	// distributor.
	// A node has to reannounce at a certain interval - if a distributor
	// does not receive an announce in a set amount of time it presumes
	// the node defunct.
	// It will be taken out of the set of active nodes and all tasks
	// enqueued for this node will be redistributed.
	Announce(nodeID pyme.NodeID, ip net.IP, port uint16) (AnnounceResponse, error)
}

type TaskID string

type TaskRating struct {
	// ID is the TaskID of the referenced task.
	ID TaskID `json:"id"`

	// Cost is the estimated execution cost for the referenced task.
	Cost float64 `json:"cost"`
}

type TaskType string

type WorkerID string