task

type Config struct {
	// Timeout for rm task in statemachine from launching to ready state
	LaunchingTimeout time.Duration `yaml:"launching_timeout"`
	// Timeout for rm task in statemachine from placing to ready state
	PlacingTimeout time.Duration `yaml:"placing_timeout"`
	// Timeout for rm task in statemachine from preempting to running state
	PreemptingTimeout time.Duration `yaml:"preempting_timeout"`
	// Timeout for rm task in statemachine from reserved to pending state
	ReservingTimeout time.Duration `yaml:"reserving_timeout"`
	// This is the backoff period how much it will backoff
	// in each retry attempt.
	PlacementRetryBackoff time.Duration `yaml:"placement_retry_backoff"`
	// This is number of retry attempts in each placement retry cycle.
	PlacementAttemptsPerCycle float64 `yaml:"placement_attempts_percycle"`
	// This is number of cycles which placement is going to repeat and
	// unplaced tasks after that are qualified for host reservation.
	PlacementRetryCycle float64 `yaml:"placement_retry_cycle"`
	// This is the policy name for the backoff
	// which is going to dictate the backoff
	PolicyName string `yaml:"backoff_policy_name"`
	// This flag will enable/disable the placement backoff policies
	EnablePlacementBackoff bool `yaml:"enable_placement_backoff"`
	// This flag will enable/disable SLA tracking of tasks
	EnableSLATracking bool `yaml:"enable_sla_tracking"`
	// This flag will enable/disable host reservation of tasks
	EnableHostReservation bool `yaml:"enable_host_reservation"`
}

type Metrics struct {
	ReadyQueueLen tally.Gauge

	TasksCountInTracker tally.Gauge

	TaskStatesGauge map[task.TaskState]tally.Gauge

	ResourcesHeldByTaskState map[task.TaskState]scalar.GaugeMaps
	LeakedResources          scalar.GaugeMaps

	ReconciliationSuccess tally.Counter
	ReconciliationFail    tally.Counter

	OrphanTasks tally.Gauge
}

type Policy interface {
	// GetNextBackoffDuration returns the next backoff duration
	// based on policy implementation
	GetNextBackoffDuration(task *resmgr.Task, config *Config) float64
	// IsCycleCompleted returns true when one placement cycle has been completed
	IsCycleCompleted(task *resmgr.Task, config *Config) bool
	// contains filtered or unexported methods
}

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

type PolicyFunc func(config *Config) (Policy, error)

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

type RMTaskState struct {
	// The state the task is in
	State task.TaskState
	// The reason for being in the state
	Reason string
	// Last time the state was updated
	LastUpdateTime time.Time
}

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

type RunTimeStats struct {
	StartTime time.Time
}

type Scheduler interface {
	// Start starts the task scheduler goroutines
	Start() error
	// Stop stops the task scheduler goroutines
	Stop() error
	// Enqueues gang (task list) into resource pool ready queue
	EnqueueGang(gang *resmgrsvc.Gang) error
	// Dequeues gang (task list) from the resource pool ready queue
	DequeueGang(maxWaitTime time.Duration, taskType resmgr.TaskType) (*resmgrsvc.Gang, error)
	// Adds an invalid task so that it can be removed from the ready queue later.
	AddInvalidTask(task *peloton.TaskID)
}

type Tracker interface {

	// AddTask adds the task to state machine
	AddTask(
		t *resmgr.Task,
		handler *eventstream.Handler,
		respool respool.ResPool,
		config *Config) error

	// GetTask gets the RM task for taskID
	GetTask(t *peloton.TaskID) *RMTask

	// SetPlacementHost Sets the placement for the tasks.
	SetPlacement(placement *resmgr.Placement)

	// DeleteTask deletes the task from the map
	DeleteTask(t *peloton.TaskID)

	// MarkItDone marks the task done and add back those
	// resources to respool
	MarkItDone(mesosTaskID string) error

	// MarkItInvalid marks the task done and invalidate them
	// in to respool by that they can be removed from the queue
	MarkItInvalid(mesosTaskID string) error

	// TasksByHosts returns all tasks of the given type running on the given hosts.
	TasksByHosts(hosts []string, taskType resmgr.TaskType) map[string][]*RMTask

	// AddResources adds the task resources to respool
	AddResources(taskID *peloton.TaskID) error

	// GetSize returns the number of the tasks in tracker
	GetSize() int64

	// Clear cleans the tracker with all the tasks
	Clear()

	// GetActiveTasks returns task states map
	GetActiveTasks(jobID string, respoolID string, states []string) map[string][]*RMTask

	// UpdateMetrics updates the task metrics
	UpdateMetrics(from task.TaskState, to task.TaskState, taskResources *scalar.Resources)

	// GetOrphanTask gets the orphan RMTask for the given mesos-task-id
	GetOrphanTask(mesosTaskID string) *RMTask

	// GetOrphanTasks returns orphan tasks
	GetOrphanTasks(respoolID string) []*RMTask
}

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

type TransitionObserver interface {
	Observe(taskID string, transitedTo task.TaskState)
}