executor

type Dispatcher struct {
	JobStats *TaskStats
	// contains filtered or unexported fields
}

type DispatcherCfg struct {

	// Number of channels used to receive back task execution results
	ChannelCount int `json:"channel_count"`

	// Channel buffer size
	ChannelCapacity int `json:"channel_capacity"`

	// Whether caller should wait for response channel availability while
	// submitting a task
	WaitForChanAvail bool `json:"wait_for_chan_avail"`
}

type ExecCfg struct {

	// How many maximum number tasks accepted by the executor when it is
	// already executing a task. These tasks will form the queue.
	TaskQueueCapacity int `json:"task_queue_capacity"`

	// If true, despite the full task queue capacity, caller invoking
	// Submit method will wait i.e. will be blocked. By default we keep it
	// false. So once the task queue is full, subsequent attempts to add a task
	// will fail as long as the queue if filled.
	WaitForAvailability bool `json:"wait_for_availability"`
}

type ExecPoolCfg struct {

	// Number of executors which will be used to handle async tasks
	AsyncTaskExecutorCount int `json:"async_task_executor_count"`

	// Number of executors which will be used to hand blocking task,
	// caller is waiting for the execution result.
	BlockingTaskExecutorCount int `json:"blocking_task_executor_count"`
}

type ExecServiceCfg struct {
	Dispatcher DispatcherCfg `json:"DispatcherSettings"`
	ExexPool   ExecPoolCfg   `json:"ExecPoolSettings"`
	Executor   ExecCfg       `json:"ExecutorSettings"`
	Monitoring MonitoringCfg `json:"MonitoringSettings"`
}

type ExecutionService struct {
	Monitor         *util.Monitor // exposed for testing purposes
	ServiceCfgInUse *ExecServiceCfg
	// contains filtered or unexported fields
}

type Executor interface {
	Start()

	Submit(t Task) error

	HowManyInQueue() int

	WaitForAvailability(wfa bool)

	Stop()
}

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

type MonitoringCfg struct {
	MonitoringFrequency int `json:"MonitoringFrequency"`
	MonDataChanBufSz    int `json:"ChannelBufferSize"`
}

type Response struct {
	// Id of the task to which this response corresponds to
	TaskId int

	// Task status - whether it succeeded or failed or some other state
	Status int

	// Output of the successfully executed task.
	// For now we assume it will be a JSON string
	Result string

	Errors []error
}

type Task interface {
	GetId() int

	Execute() Response

	SetRespChan(rc chan Response)

	GetRespChan() chan Response

	IsBlocking() bool
}

type TaskStats struct {
	sync.Mutex
	UpSinceWhen            time.Time `json:"up_since_when"`
	TotalTasksSubmitted    int       `json:"total_tasks_submitted"`
	BlockingTasksSubmitted int       `json:"blocking_tasks_submitted"`
	AsyncTasksSubmitted    int       `json:"async_tasks_submitted"`
	TasksInExecution       int       `json:"tasks_in_execution"`
}

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