concurrency

type Task ¶

type Task interface {
	TaskCore
	TaskGuard
}

Task is the interface of a task running in goroutine, allowing to identity (indirectly) goroutines

func NewTask() (Task, fail.Error)

func NewTaskWithContext(ctx context.Context, options ...data.ImmutableKeyValue) (Task, fail.Error)

func NewTaskWithParent(parentTask Task, options ...data.ImmutableKeyValue) (Task, fail.Error)

func NewUnbreakableTask() (Task, fail.Error)

func RootTask() (rt Task, ferr fail.Error)

func TaskFromContext(ctx context.Context) (Task, fail.Error)

func TaskFromContextOrVoid(ctx context.Context) (Task, fail.Error)

func VoidTask() (Task, fail.Error)

type TaskAction ¶

type TaskAction func(t Task, parameters TaskParameters) (TaskResult, fail.Error)

TaskAction defines the type of the function that can be started by a Task. NOTE: you have to check if task is aborted inside this function using method t.ErrAborted(),

to be able to stop the process when task is aborted (no matter what
the abort reason is), and permit ending properly. Otherwise, this may lead to goroutine leak
(there is no good way to stop forcibly a goroutine).

Example: task.Start(func(task concurrency.Task, p TaskParameters) (concurrency.TaskResult, fail.Error) { ...

   for {
       if task.ErrAborted() {
           break // or return
       }
       ...
   }
   return nil
}, nil)

type TaskCore ¶

type TaskCore interface {
	Abort() fail.Error
	AbortWithCause(fail.Error) fail.Error
	Abortable() (bool, fail.Error)
	Aborted() bool
	DisarmAbortSignal() func()
	ID() (string, fail.Error)
	Signature() string
	Status() (TaskStatus, fail.Error)
	Context() context.Context
	LastError() (error, fail.Error)
	Result() (TaskResult, fail.Error)
	SetID(string) fail.Error

	Run(fn TaskAction, params TaskParameters, options ...data.ImmutableKeyValue) (TaskResult, fail.Error)
	Start(fn TaskAction, params TaskParameters, options ...data.ImmutableKeyValue) (Task, fail.Error)
	StartWithTimeout(fn TaskAction, params TaskParameters, timeout time.Duration, options ...data.ImmutableKeyValue) (Task, fail.Error)
}

TaskCore is the interface of core methods to control Task and TaskGroup

type TaskGroup ¶

type TaskGroup interface {
	TaskCore
	TaskGuard
	TaskGroupGuard

	GroupStatus() (map[TaskStatus][]string, fail.Error)
}

TaskGroup is the task group interface

type TaskGroupGuard ¶

type TaskGroupGuard interface {
	Started() (uint, fail.Error)
	TryWaitGroup() (bool, TaskGroupResult, fail.Error)
	WaitGroup() (TaskGroupResult, fail.Error)
	WaitGroupFor(time.Duration) (bool, TaskGroupResult, fail.Error)
}

TaskGroupGuard is the task group interface defining method to wait the TaskGroup

type TaskGroupResult ¶

type TaskGroupResult = map[string]TaskResult

TaskGroupResult is a map of the TaskResult of each task The index is the ID of the sub-Task running the action.

type TaskGuard ¶

type TaskGuard interface {
	TryWait() (bool, TaskResult, fail.Error)
	Wait() (TaskResult, fail.Error)
	WaitFor(time.Duration) (bool, TaskResult, fail.Error)
}

TaskGuard ...

type TaskParameters ¶

type TaskParameters interface{}

TaskParameters ...

type TaskResult ¶

type TaskResult interface{}

TaskResult ...

type TaskStatus ¶

type TaskStatus int

TaskStatus ...

const (
	UNKNOWN TaskStatus = iota // status is unknown
	READY                     // the task is ready to start
	RUNNING                   // the task is running
	DONE                      // the task has run and is done
	ABORTED                   // the task has been aborted
	TIMEOUT                   // the task ran out of time
)