README
¶
gotask
Simple routine group library for Golang. Main purpose is to gracefully shutdown complex multitask apps.
go get github.com/void616/gotask
Examples
Group
Make a group, add tasks, run it and wait for completion.
t1, _ := gotask.NewTask("MyTask #1", func() { log.Println("Routine 1") })
t2, _ := gotask.NewTask("MyTask #2", func() { log.Println("Routine 2") })
g := gotask.NewGroup("MyGroup")
g.Add(t1)
g.Add(t2)
g.Run()
g.Wait()
Output:
Routine 2
Routine 1
Task lifetime
Pass token into the routine to control it's lifetime.
result := 0
routine := func(token *gotask.Token) {
for {
result++
// sleep with alertness
if token.Sleep(time.Minute * 60) {
break
}
}
}
t, _ := gotask.NewTask("MyTask", routine)
token, waiter, _ := t.Run()
token.Stop()
waiter.Wait()
log.Println("Result", result)
Output:
Result 1
Panic
Stop group of tasks on panic.
g := gotask.NewGroup("MyGroup")
routine1 := func(token *gotask.Token) {
log.Println("Routine 1 begin")
defer log.Println("Routine 1 end")
token.Sleep(time.Minute * 60)
}
routine2 := func(token *gotask.Token) {
log.Println("Routine 2 begin")
defer log.Println("Routine 2 end")
panic("panic!")
}
t1, _ := gotask.NewTask("MyTask #1", routine1)
t2, _ := gotask.NewTask("MyTask #2", routine2)
t2.Recover(func(v interface{}) {
g.Stop()
})
g.Add(t1)
g.Add(t2)
g.Run()
g.Wait()
Output:
Routine 1 begin
Routine 2 begin
Routine 2 end
Routine 1 end
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var ( // ErrInvalidRoutine means routine has invalid type ErrInvalidRoutine = errors.New("invalid routine") // ErrInvalidState means a task/group state is invalid for current operation (broken flow) ErrInvalidState = errors.New("invalid state") )
Functions ¶
This section is empty.
Types ¶
type Group ¶
type Group struct {
// contains filtered or unexported fields
}
Group is a group of Tasks.
func (*Group) Add ¶
Add adds a Task. If the Group is running, `ErrInvalidState` error will be returned.
func (*Group) Log ¶ added in v1.0.2
Log sets a Logger. If the Group is running, `ErrInvalidState` error will be returned.
func (*Group) Run ¶
Run starts Group's Tasks. If the Group is running, `ErrInvalidState` error will be returned. Run will ignore any Task that is already running (i.e. Task.Run() return error).
func (*Group) Stop ¶
func (g *Group) Stop()
Stop requires Group's Tasks to stop. Does nothing if the Group is not running.
func (*Group) TokenOf ¶ added in v1.0.2
TokenOf returns specific Task Token. If the Task wasn't started by the Group or Group isn't running, `ErrInvalidState` will be returned.
type Logger ¶ added in v1.0.2
type Logger interface {
Log(...interface{})
}
Logger logs events for debug
type Recover ¶
type Recover func(interface{})
Recover is a callback function template that will be called on routine panic.
type Task ¶
type Task struct {
// contains filtered or unexported fields
}
Task is a named routine that does something in parallel.
func NewTask ¶
NewTask instance. Arg `routine` should be an entity of type: func(), func(*Token), func(...interface{}), func(*Token, ...interface{}). Otherwise `ErrInvalidRoutine` will be returned.
func (*Task) Log ¶ added in v1.0.2
Log sets a Logger. If the Task is running, `ErrInvalidState` error will be returned.
func (*Task) Recover ¶
Recover specifies a callback function that will be called in case of routine's panic.
type Token ¶
type Token struct {
// contains filtered or unexported fields
}
Token controls a Task's lifetime.
func (*Token) Sleep ¶
Sleep sleeps specified amount of time or until related Task is requested to stop. Returns `true` if a stop-event received while sleeping. In general case this method is used from within a routine.
Source Files