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) Name() string
  • func (d *AtomicGroup) SetName(name string)
  • func (d *AtomicGroup) Stop()
  • func (d *AtomicGroup) Wait()
  • func (d *AtomicGroup) WaitAsync() <-chan struct{}
• type AtomicGroupKey
• type Command
• type Commander
• type ErrorCounter
  • func NewErrorCounter(maxErrors int, msg string) *ErrorCounter
  • func (ec *ErrorCounter) Error() error
  • func (ec *ErrorCounter) MaxErrors() int
  • func (ec *ErrorCounter) SetError(err error) bool
• type FiniteCommand
  • func (c FiniteCommand) Run(ctx context.Context) error
• type FiniteCommandWithErrorCounter
  • func (c FiniteCommandWithErrorCounter) 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 Runner
• 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 with error.

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) Name

func (d *AtomicGroup) Name() string

func (*AtomicGroup) SetName

func (d *AtomicGroup) SetName(name string)

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 AtomicGroupKey

type AtomicGroupKey string

type Command

type Command func(context.Context) error

type Commander

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

type ErrorCounter

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

func NewErrorCounter

func NewErrorCounter(maxErrors int, msg string) *ErrorCounter

func (*ErrorCounter) Error

func (ec *ErrorCounter) Error() error

func (*ErrorCounter) MaxErrors

func (ec *ErrorCounter) MaxErrors() int

func (*ErrorCounter) SetError

func (ec *ErrorCounter) SetError(err error) bool

Returns false in case of counter overflow

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 FiniteCommandWithErrorCounter

type FiniteCommandWithErrorCounter struct {
	FiniteCommand
	*ErrorCounter
}

func (FiniteCommandWithErrorCounter) Run

func (c FiniteCommandWithErrorCounter) 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 for when the task arguments might change the result
	ReplacementPolicyCancelOld ReplacementPolicy = iota
	// ReplacementPolicyIgnoreNew for when the task arguments doesn't change the result
	ReplacementPolicyIgnoreNew
)

type Runner

type Runner interface {
	Run(context.Context) error
}

type Scheduler

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

Scheduler ensures that only one task of a type is running at a time.

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
}