async

Documentation

Index

• Variables
• type AtomicGroup
  • func NewAtomicGroup(parent context.Context) *AtomicGroup
  • func (d *AtomicGroup) Add(cmd Command)
  • func (d *AtomicGroup) Error() error
  • func (d *AtomicGroup) Stop()
  • func (d *AtomicGroup) Wait()
  • func (d *AtomicGroup) WaitAsync() <-chan struct{}
• type Command
• type Commander
• type FiniteCommand
  • func (c FiniteCommand) Run(ctx context.Context) error
• type Group
  • func NewGroup(parent context.Context) *Group
  • func (g *Group) Add(cmd Command)
  • func (g *Group) Stop()
  • func (g *Group) Wait()
  • func (g *Group) WaitAsync() <-chan struct{}
• type InfiniteCommand
  • func (c InfiniteCommand) Run(ctx context.Context) error
• type MultiClientScheduler
  • func NewMultiClientScheduler() *MultiClientScheduler
  • func (s *MultiClientScheduler) Enqueue(requestID int32, taskType TaskType, taskFn taskFunction, resFn resultFunction) (ignored bool)
  • func (s *MultiClientScheduler) Stop()
• type QueuedAtomicGroup
  • func NewQueuedAtomicGroup(parent context.Context, limit uint32) *QueuedAtomicGroup
  • func (d *QueuedAtomicGroup) Add(cmd Command)
• type ReplacementPolicy
• type Scheduler
  • func NewScheduler() *Scheduler
  • func (s *Scheduler) Enqueue(taskType TaskType, taskFn taskFunction, resFn resultFunction) (ignored bool)
  • func (s *Scheduler) Stop()
• type SingleShotCommand
  • func (c SingleShotCommand) Run(ctx context.Context) error
• type TaskType

Variables

var ErrTaskOverwritten = errors.New("task overwritten")

Types

type AtomicGroup

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

AtomicGroup terminates as soon as first goroutine terminates..

func NewAtomicGroup

func NewAtomicGroup(parent context.Context) *AtomicGroup

func (*AtomicGroup) Add

func (d *AtomicGroup) Add(cmd Command)

Go spawns function in a goroutine and stores results or errors.

func (*AtomicGroup) Error

func (d *AtomicGroup) Error() error

Error stores an error that was reported by any of the downloader. Should be called after Wait.

func (*AtomicGroup) Stop

func (d *AtomicGroup) Stop()

func (*AtomicGroup) Wait

func (d *AtomicGroup) Wait()

Wait for all downloaders to finish.

func (*AtomicGroup) WaitAsync

func (d *AtomicGroup) WaitAsync() <-chan struct{}

type Command

type Command func(context.Context) error

type Commander

type Commander interface {
	Command(inteval ...time.Duration) Command
}

type FiniteCommand

type FiniteCommand struct {
	Interval time.Duration
	Runable  func(context.Context) error
}

FiniteCommand terminates when error is nil.

func (FiniteCommand) Run

func (c FiniteCommand) Run(ctx context.Context) error

type Group

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

func NewGroup

func NewGroup(parent context.Context) *Group

func (*Group) Add

func (g *Group) Add(cmd Command)

func (*Group) Stop

func (g *Group) Stop()

func (*Group) Wait

func (g *Group) Wait()

func (*Group) WaitAsync

func (g *Group) WaitAsync() <-chan struct{}

type InfiniteCommand

type InfiniteCommand struct {
	Interval time.Duration
	Runable  func(context.Context) error
}

InfiniteCommand runs until context is closed.

func (InfiniteCommand) Run

func (c InfiniteCommand) Run(ctx context.Context) error

type MultiClientScheduler

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

func NewMultiClientScheduler

func NewMultiClientScheduler() *MultiClientScheduler

func (*MultiClientScheduler) Enqueue

func (s *MultiClientScheduler) Enqueue(requestID int32, taskType TaskType, taskFn taskFunction, resFn resultFunction) (ignored bool)

func (*MultiClientScheduler) Stop

func (s *MultiClientScheduler) Stop()

type QueuedAtomicGroup

type QueuedAtomicGroup struct {
	*AtomicGroup
	// contains filtered or unexported fields
}

func NewQueuedAtomicGroup

func NewQueuedAtomicGroup(parent context.Context, limit uint32) *QueuedAtomicGroup

func (*QueuedAtomicGroup) Add

func (d *QueuedAtomicGroup) Add(cmd Command)

type ReplacementPolicy

type ReplacementPolicy = int

const (
	ReplacementPolicyCancelOld ReplacementPolicy = iota
	ReplacementPolicyIgnoreNew
)

type Scheduler

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

func NewScheduler

func NewScheduler() *Scheduler

func (*Scheduler) Enqueue

func (s *Scheduler) Enqueue(taskType TaskType, taskFn taskFunction, resFn resultFunction) (ignored bool)

Enqueue provides a queue of task types allowing only one task at a time of the corresponding type. The running task is the first one in the queue (s.queue.Oldest())

Schedule policy for new tasks

• pushed at the back of the queue (s.queue.PushBack()) if none of the same time already scheduled
• overwrite the queued one of the same type, depending on the policy
• In case of ReplacementPolicyIgnoreNew, the new task will be ignored
• In case of ReplacementPolicyCancelOld, the old running task will be canceled or if not yet run overwritten and the new one will be executed when its turn comes.

The task function (taskFn) might not be executed if

• the task is ignored
• the task is overwritten. The result function (resFn) will be called with ErrTaskOverwritten

The result function (resFn) will always be called if the task is not ignored

func (*Scheduler) Stop

func (s *Scheduler) Stop()

type SingleShotCommand

type SingleShotCommand struct {
	Interval time.Duration
	Init     func(context.Context) error
	Runable  func(context.Context) error
}

SingleShotCommand runs once.

func (SingleShotCommand) Run

func (c SingleShotCommand) Run(ctx context.Context) error

type TaskType

type TaskType struct {
	ID     int64
	Policy ReplacementPolicy
}