queue

Jul 16, 2023

Changes in this version

+ type BaseConfig struct

+ ConnStr string

+ DataFullDir string

+ Length int

+ ManagedName string

+ QueueFullName string

+ SetFullName string

+ type HandlerFuncT func(...T) (unhandled []T)

+ type ManagedWorkerPoolQueue interface

+ FlushWithContext func(ctx context.Context, timeout time.Duration) error

+ GetItemTypeName func() string

+ GetName func() string

+ GetQueueItemNumber func() int

+ GetType func() string

+ GetWorkerActiveNumber func() int

+ GetWorkerMaxNumber func() int

+ GetWorkerNumber func() int

+ RemoveAllItems func(ctx context.Context) error

+ SetWorkerMaxNumber func(num int)

type Manager

+ func (m *Manager) AddManagedQueue(managed ManagedWorkerPoolQueue)

+ type WorkerPoolQueue struct

+ func CreateSimpleQueue(ctx context.Context, name string, handler HandlerFuncT[T]) *WorkerPoolQueue[T]

+ func NewWorkerPoolQueueWithContext(ctx context.Context, name string, queueSetting setting.QueueSettings, ...) (*WorkerPoolQueue[T], error)

+ func (q *WorkerPoolQueue[T]) Cancel()

+ func (q *WorkerPoolQueue[T]) FlushWithContext(ctx context.Context, timeout time.Duration) (err error)

+ func (q *WorkerPoolQueue[T]) GetItemTypeName() string

+ func (q *WorkerPoolQueue[T]) GetName() string

+ func (q *WorkerPoolQueue[T]) GetQueueItemNumber() int

+ func (q *WorkerPoolQueue[T]) GetType() string

+ func (q *WorkerPoolQueue[T]) GetWorkerActiveNumber() int

+ func (q *WorkerPoolQueue[T]) GetWorkerMaxNumber() int

+ func (q *WorkerPoolQueue[T]) GetWorkerNumber() int

+ func (q *WorkerPoolQueue[T]) Has(data T) (bool, error)

+ func (q *WorkerPoolQueue[T]) Push(data T) error

+ func (q *WorkerPoolQueue[T]) RemoveAllItems(ctx context.Context) error

+ func (q *WorkerPoolQueue[T]) Run()

+ func (q *WorkerPoolQueue[T]) SetWorkerMaxNumber(num int)

+ func (q *WorkerPoolQueue[T]) ShutdownWait(timeout time.Duration)

Jul 30, 2022

Changes in this version

type ByteFIFO

+ PushBack func(ctx context.Context, data []byte) error

type ByteFIFOQueue

+ func (q *ByteFIFOQueue) Flush(timeout time.Duration) error

+ func (q *ByteFIFOQueue) NumberInQueue() int64

+ func (q *ByteFIFOQueue) PushBack(data Data) error

type ChannelQueue

+ func (q *ChannelQueue) Flush(timeout time.Duration) error

+ func (q *ChannelQueue) FlushWithContext(ctx context.Context) error

type ChannelUniqueQueue

+ func (q *ChannelUniqueQueue) Flush(timeout time.Duration) error

+ func (q *ChannelUniqueQueue) FlushWithContext(ctx context.Context) error

type DummyByteFIFO

+ func (*DummyByteFIFO) PushBack(ctx context.Context, data []byte) error

type LevelQueueByteFIFO

+ func (fifo *LevelQueueByteFIFO) PushBack(ctx context.Context, data []byte) error

type LevelUniqueQueueByteFIFO

+ func (fifo *LevelUniqueQueueByteFIFO) PushBack(ctx context.Context, data []byte) error

type ManagedPool

+ NumberInQueue func() int64

type ManagedQueue

+ func (q *ManagedQueue) Flushable() bool

+ func (q *ManagedQueue) IsPaused() bool

+ func (q *ManagedQueue) NumberInQueue() int64

+ func (q *ManagedQueue) Pausable() bool

+ func (q *ManagedQueue) Pause()

+ func (q *ManagedQueue) Resume()

+ type Pausable interface

+ IsPaused func() bool

+ IsPausedIsResumed func() (paused, resumed <-chan struct{})

+ Pause func()

+ Resume func()

type PersistableChannelQueue

+ func (q *PersistableChannelQueue) IsPaused() bool

+ func (q *PersistableChannelQueue) IsPausedIsResumed() (<-chan struct{}, <-chan struct{})

+ func (q *PersistableChannelQueue) Pause()

+ func (q *PersistableChannelQueue) PushBack(data Data) error

+ func (q *PersistableChannelQueue) Resume()

type PersistableChannelUniqueQueue

+ func (q *PersistableChannelUniqueQueue) IsPaused() bool

+ func (q *PersistableChannelUniqueQueue) IsPausedIsResumed() (paused, resumed <-chan struct{})

+ func (q *PersistableChannelUniqueQueue) Pause()

+ func (q *PersistableChannelUniqueQueue) PushBack(data Data) error

+ func (q *PersistableChannelUniqueQueue) Resume()

+ type PushBackable interface

+ PushBack func(Data) error

type RedisByteFIFO

+ func (fifo *RedisByteFIFO) PushBack(ctx context.Context, data []byte) error

type RedisUniqueByteFIFO

+ func (fifo *RedisUniqueByteFIFO) PushBack(ctx context.Context, data []byte) error

type WorkerPool

+ func (p *WorkerPool) IsPaused() bool

+ func (p *WorkerPool) IsPausedIsResumed() (<-chan struct{}, <-chan struct{})

+ func (p *WorkerPool) NumberInQueue() int64

+ func (p *WorkerPool) Pause()

+ func (p *WorkerPool) Resume()

type WorkerPoolConfiguration

+ Name string

type WrappedQueue

+ func (q *WrappedQueue) IsPaused() bool

+ func (q *WrappedQueue) IsPausedIsResumed() (paused, resumed <-chan struct{})

+ func (q *WrappedQueue) Pause()

+ func (q *WrappedQueue) Resume()

Feb 24, 2022

Changes in this version

type WorkerPool

+ func (p *WorkerPool) HasNoWorkerScaling() bool

Feb 6, 2022

Changes in this version

type ManagedPool

+ Done func() <-chan struct{}

type WorkerPool

+ func (p *WorkerPool) Done() <-chan struct{}

Aug 22, 2021

Changes in this version

type ByteFIFOQueueConfiguration

+ WaitOnEmpty bool

type ChannelQueue

+ func (q *ChannelQueue) Shutdown()

+ func (q *ChannelQueue) Terminate()

type ChannelUniqueQueue

+ func (q *ChannelUniqueQueue) Shutdown()

+ func (q *ChannelUniqueQueue) Terminate()

type PersistableChannelUniqueQueue

+ func (q *PersistableChannelUniqueQueue) FlushWithContext(ctx context.Context) error

+ func (q *PersistableChannelUniqueQueue) IsEmpty() bool

Apr 11, 2021

Changes in this version

type ByteFIFOQueue

+ func (q *ByteFIFOQueue) IsShutdown() <-chan struct{}

+ func (q *ByteFIFOQueue) IsTerminated() <-chan struct{}

+ type Mappable interface

+ MapTo func(v interface{}) error

Dec 2, 2020

Changes in this version

+ type Immediate struct

+ func (*Immediate) Flush(time.Duration) error

+ func (*Immediate) FlushWithContext(context.Context) error

+ func (*Immediate) Has(Data) (bool, error)

+ func (*Immediate) IsEmpty() bool

+ func (*Immediate) Run(_, _ func(context.Context, func()))

+ func (q *Immediate) Push(data Data) error

+ func (q *Immediate) PushFunc(data Data, f func() error) error

type LevelQueueConfiguration

+ ConnectionString string

+ QueueName string

type LevelUniqueQueueConfiguration

+ ConnectionString string

+ QueueName string

type Queue

+ func NewImmediate(handler HandlerFunc, opts, exemplar interface{}) (Queue, error)

type RedisByteFIFOConfiguration

+ ConnectionString string

type Type

+ const ImmediateType

Jun 18, 2020

Changes in this version

+ var ErrAlreadyInQueue = fmt.Errorf("already in queue")

+ type ByteFIFO interface

+ Close func() error

+ Len func() int64

+ Pop func() ([]byte, error)

+ PushFunc func(data []byte, fn func() error) error

+ type ByteFIFOQueue struct

+ func NewByteFIFOQueue(typ Type, byteFIFO ByteFIFO, handle HandlerFunc, cfg, exemplar interface{}) (*ByteFIFOQueue, error)

+ func (q *ByteFIFOQueue) IsEmpty() bool

+ func (q *ByteFIFOQueue) Name() string

+ func (q *ByteFIFOQueue) Push(data Data) error

+ func (q *ByteFIFOQueue) PushFunc(data Data, fn func() error) error

+ func (q *ByteFIFOQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ func (q *ByteFIFOQueue) Shutdown()

+ func (q *ByteFIFOQueue) Terminate()

+ type ByteFIFOQueueConfiguration struct

+ Name string

+ Workers int

+ type ByteFIFOUniqueQueue struct

+ func NewByteFIFOUniqueQueue(typ Type, byteFIFO UniqueByteFIFO, handle HandlerFunc, ...) (*ByteFIFOUniqueQueue, error)

+ func (q *ByteFIFOUniqueQueue) Has(data Data) (bool, error)

+ type ChannelUniqueQueue struct

+ func (q *ChannelUniqueQueue) Has(data Data) (bool, error)

+ func (q *ChannelUniqueQueue) Name() string

+ func (q *ChannelUniqueQueue) Push(data Data) error

+ func (q *ChannelUniqueQueue) PushFunc(data Data, fn func() error) error

+ func (q *ChannelUniqueQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ type ChannelUniqueQueueConfiguration ChannelQueueConfiguration

+ type DummyByteFIFO struct

+ func (*DummyByteFIFO) Close() error

+ func (*DummyByteFIFO) Len() int64

+ func (*DummyByteFIFO) Pop() ([]byte, error)

+ func (*DummyByteFIFO) PushFunc(data []byte, fn func() error) error

type DummyQueue

+ func (*DummyQueue) Flush(time.Duration) error

+ func (*DummyQueue) FlushWithContext(context.Context) error

+ func (*DummyQueue) Has(Data) (bool, error)

+ func (*DummyQueue) IsEmpty() bool

+ func (*DummyQueue) PushFunc(Data, func() error) error

+ type DummyUniqueByteFIFO struct

+ func (*DummyUniqueByteFIFO) Has([]byte) (bool, error)

+ type Flushable interface

+ Flush func(time.Duration) error

+ FlushWithContext func(ctx context.Context) error

+ IsEmpty func() bool

+ type LevelQueueByteFIFO struct

+ func NewLevelQueueByteFIFO(dataDir string) (*LevelQueueByteFIFO, error)

+ func (fifo *LevelQueueByteFIFO) Close() error

+ func (fifo *LevelQueueByteFIFO) Len() int64

+ func (fifo *LevelQueueByteFIFO) Pop() ([]byte, error)

+ func (fifo *LevelQueueByteFIFO) PushFunc(data []byte, fn func() error) error

+ type LevelUniqueQueue struct

+ type LevelUniqueQueueByteFIFO struct

+ func NewLevelUniqueQueueByteFIFO(dataDir string) (*LevelUniqueQueueByteFIFO, error)

+ func (fifo *LevelUniqueQueueByteFIFO) Close() error

+ func (fifo *LevelUniqueQueueByteFIFO) Has(data []byte) (bool, error)

+ func (fifo *LevelUniqueQueueByteFIFO) Len() int64

+ func (fifo *LevelUniqueQueueByteFIFO) Pop() ([]byte, error)

+ func (fifo *LevelUniqueQueueByteFIFO) PushFunc(data []byte, fn func() error) error

+ type LevelUniqueQueueConfiguration struct

+ DataDir string

type ManagedPool

+ SetPoolSettings func(maxNumberOfWorkers, boostWorkers int, timeout time.Duration)

type ManagedQueue

+ Managed interface{}

+ func (q *ManagedQueue) Flush(timeout time.Duration) error

+ func (q *ManagedQueue) IsEmpty() bool

+ func (q *ManagedQueue) SetPoolSettings(maxNumberOfWorkers, boostWorkers int, timeout time.Duration)

type Manager

+ func (m *Manager) FlushAll(baseCtx context.Context, timeout time.Duration) error

type PersistableChannelQueue

+ func (q *PersistableChannelQueue) Flush(timeout time.Duration) error

+ func (q *PersistableChannelQueue) FlushWithContext(ctx context.Context) error

+ func (q *PersistableChannelQueue) IsEmpty() bool

+ type PersistableChannelUniqueQueue struct

+ func (q *PersistableChannelUniqueQueue) Flush(timeout time.Duration) error

+ func (q *PersistableChannelUniqueQueue) Has(data Data) (bool, error)

+ func (q *PersistableChannelUniqueQueue) Name() string

+ func (q *PersistableChannelUniqueQueue) Push(data Data) error

+ func (q *PersistableChannelUniqueQueue) PushFunc(data Data, fn func() error) error

+ func (q *PersistableChannelUniqueQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ func (q *PersistableChannelUniqueQueue) Shutdown()

+ func (q *PersistableChannelUniqueQueue) Terminate()

+ type PersistableChannelUniqueQueueConfiguration struct

+ BatchLength int

+ BlockTimeout time.Duration

+ BoostTimeout time.Duration

+ BoostWorkers int

+ DataDir string

+ MaxAttempts int

+ MaxWorkers int

+ Name string

+ QueueLength int

+ Timeout time.Duration

+ Workers int

type PoolWorkers

+ IsFlusher bool

type Queue

+ func NewChannelUniqueQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewLevelUniqueQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewPersistableChannelUniqueQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewRedisUniqueQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewWrappedUniqueQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ type RedisByteFIFO struct

+ func NewRedisByteFIFO(config RedisByteFIFOConfiguration) (*RedisByteFIFO, error)

+ func (fifo *RedisByteFIFO) Close() error

+ func (fifo *RedisByteFIFO) Len() int64

+ func (fifo *RedisByteFIFO) Pop() ([]byte, error)

+ func (fifo *RedisByteFIFO) PushFunc(data []byte, fn func() error) error

+ type RedisByteFIFOConfiguration struct

+ Addresses string

+ DBIndex int

+ Network string

+ Password string

+ QueueName string

+ type RedisUniqueByteFIFO struct

+ func NewRedisUniqueByteFIFO(config RedisUniqueByteFIFOConfiguration) (*RedisUniqueByteFIFO, error)

+ func (fifo *RedisUniqueByteFIFO) Has(data []byte) (bool, error)

+ func (fifo *RedisUniqueByteFIFO) Pop() ([]byte, error)

+ func (fifo *RedisUniqueByteFIFO) PushFunc(data []byte, fn func() error) error

+ type RedisUniqueByteFIFOConfiguration struct

+ SetName string

+ type RedisUniqueQueue struct

+ type RedisUniqueQueueConfiguration struct

type Type

+ const ChannelUniqueQueueType

+ const LevelUniqueQueueType

+ const PersistableChannelUniqueQueueType

+ const RedisUniqueQueueType

+ const WrappedUniqueQueueType

+ type UniqueByteFIFO interface

+ Has func(data []byte) (bool, error)

+ type UniqueQueue interface

+ Has func(Data) (bool, error)

+ PushFunc func(Data, func() error) error

+ func CreateUniqueQueue(name string, handle HandlerFunc, exemplar interface{}) UniqueQueue

type WorkerPool

+ func NewWorkerPool(handle HandlerFunc, config WorkerPoolConfiguration) *WorkerPool

+ func (p *WorkerPool) Flush(timeout time.Duration) error

+ func (p *WorkerPool) FlushWithContext(ctx context.Context) error

+ func (p *WorkerPool) IsEmpty() bool

+ func (p *WorkerPool) SetPoolSettings(maxNumberOfWorkers, boostWorkers int, timeout time.Duration)

+ type WorkerPoolConfiguration struct

+ BatchLength int

+ BlockTimeout time.Duration

+ BoostTimeout time.Duration

+ BoostWorkers int

+ MaxWorkers int

+ QueueLength int

type WrappedQueue

+ func (q *WrappedQueue) Flush(timeout time.Duration) error

+ func (q *WrappedQueue) FlushWithContext(ctx context.Context) error

+ func (q *WrappedQueue) IsEmpty() bool

+ type WrappedUniqueQueue struct

+ func (q *WrappedUniqueQueue) Has(data Data) (bool, error)

+ func (q *WrappedUniqueQueue) IsEmpty() bool

+ func (q *WrappedUniqueQueue) Push(data Data) error

+ func (q *WrappedUniqueQueue) PushFunc(data Data, fn func() error) error

+ type WrappedUniqueQueueConfiguration struct

+ Config interface{}

+ MaxAttempts int

+ Name string

+ QueueLength int

+ Timeout time.Duration

+ Underlying Type

Feb 10, 2020

Changes in this version

+ func IsErrInvalidConfiguration(err error) bool

+ func RegisteredTypesAsString() []string

+ type ChannelQueue struct

+ func (c *ChannelQueue) Name() string

+ func (c *ChannelQueue) Push(data Data) error

+ func (c *ChannelQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ type ChannelQueueConfiguration struct

+ BatchLength int

+ BlockTimeout time.Duration

+ BoostTimeout time.Duration

+ BoostWorkers int

+ MaxWorkers int

+ Name string

+ QueueLength int

+ Workers int

+ type Data interface

+ type DummyQueue struct

+ func (b *DummyQueue) Push(Data) error

+ func (b *DummyQueue) Run(_, _ func(context.Context, func()))

+ type ErrInvalidConfiguration struct

+ func (err ErrInvalidConfiguration) Error() string

+ type HandlerFunc func(...Data)

+ type LevelQueue struct

+ func (l *LevelQueue) Name() string

+ func (l *LevelQueue) Push(data Data) error

+ func (l *LevelQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ func (l *LevelQueue) Shutdown()

+ func (l *LevelQueue) Terminate()

+ type LevelQueueConfiguration struct

+ BatchLength int

+ BlockTimeout time.Duration

+ BoostTimeout time.Duration

+ BoostWorkers int

+ DataDir string

+ MaxWorkers int

+ Name string

+ QueueLength int

+ Workers int

+ type ManagedPool interface

+ AddWorkers func(number int, timeout time.Duration) context.CancelFunc

+ BlockTimeout func() time.Duration

+ BoostTimeout func() time.Duration

+ BoostWorkers func() int

+ MaxNumberOfWorkers func() int

+ NumberOfWorkers func() int

+ SetMaxNumberOfWorkers func(int)

+ SetSettings func(maxNumberOfWorkers, boostWorkers int, timeout time.Duration)

+ type ManagedQueue struct

+ Configuration interface{}

+ ExemplarType string

+ Name string

+ Pool ManagedPool

+ PoolWorkers map[int64]*PoolWorkers

+ QID int64

+ Queue Queue

+ Type Type

+ func (q *ManagedQueue) AddWorkers(number int, timeout time.Duration) context.CancelFunc

+ func (q *ManagedQueue) BlockTimeout() time.Duration

+ func (q *ManagedQueue) BoostTimeout() time.Duration

+ func (q *ManagedQueue) BoostWorkers() int

+ func (q *ManagedQueue) CancelWorkers(pid int64)

+ func (q *ManagedQueue) MaxNumberOfWorkers() int

+ func (q *ManagedQueue) NumberOfWorkers() int

+ func (q *ManagedQueue) RegisterWorkers(number int, start time.Time, hasTimeout bool, timeout time.Time, ...) int64

+ func (q *ManagedQueue) RemoveWorkers(pid int64)

+ func (q *ManagedQueue) SetSettings(maxNumberOfWorkers, boostWorkers int, timeout time.Duration)

+ func (q *ManagedQueue) Workers() []*PoolWorkers

+ type ManagedQueueList []*ManagedQueue

+ func (l ManagedQueueList) Len() int

+ func (l ManagedQueueList) Less(i, j int) bool

+ func (l ManagedQueueList) Swap(i, j int)

+ type Manager struct

+ Queues map[int64]*ManagedQueue

+ func GetManager() *Manager

+ func (m *Manager) Add(queue Queue, t Type, configuration, exemplar interface{}, pool ManagedPool) int64

+ func (m *Manager) GetManagedQueue(qid int64) *ManagedQueue

+ func (m *Manager) ManagedQueues() []*ManagedQueue

+ func (m *Manager) Remove(qid int64)

+ type Named interface

+ Name func() string

+ type NewQueueFunc func(handler HandlerFunc, config interface{}, exemplar interface{}) (Queue, error)

+ type PersistableChannelQueue struct

+ func (p *PersistableChannelQueue) Name() string

+ func (p *PersistableChannelQueue) Push(data Data) error

+ func (p *PersistableChannelQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ func (p *PersistableChannelQueue) Shutdown()

+ func (p *PersistableChannelQueue) Terminate()

+ type PersistableChannelQueueConfiguration struct

+ BatchLength int

+ BlockTimeout time.Duration

+ BoostTimeout time.Duration

+ BoostWorkers int

+ DataDir string

+ MaxAttempts int

+ MaxWorkers int

+ Name string

+ QueueLength int

+ Timeout time.Duration

+ Workers int

+ type PoolWorkers struct

+ Cancel context.CancelFunc

+ HasTimeout bool

+ PID int64

+ Start time.Time

+ Timeout time.Time

+ Workers int

+ type PoolWorkersList []*PoolWorkers

+ func (l PoolWorkersList) Len() int

+ func (l PoolWorkersList) Less(i, j int) bool

+ func (l PoolWorkersList) Swap(i, j int)

+ type Queue interface

+ Push func(Data) error

+ Run func(atShutdown, atTerminate func(context.Context, func()))

+ func CreateQueue(name string, handle HandlerFunc, exemplar interface{}) Queue

+ func NewChannelQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewDummyQueue(handler HandlerFunc, opts, exemplar interface{}) (Queue, error)

+ func NewLevelQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewPersistableChannelQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewQueue(queueType Type, handlerFunc HandlerFunc, opts, exemplar interface{}) (Queue, error)

+ func NewRedisQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ func NewWrappedQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)

+ type RedisQueue struct

+ func (r *RedisQueue) Name() string

+ func (r *RedisQueue) Push(data Data) error

+ func (r *RedisQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ func (r *RedisQueue) Shutdown()

+ func (r *RedisQueue) Terminate()

+ type RedisQueueConfiguration struct

+ Addresses string

+ BatchLength int

+ BlockTimeout time.Duration

+ BoostTimeout time.Duration

+ BoostWorkers int

+ DBIndex int

+ MaxWorkers int

+ Name string

+ Network string

+ Password string

+ QueueLength int

+ QueueName string

+ Workers int

+ type Shutdownable interface

+ Shutdown func()

+ Terminate func()

+ type Type string

+ const ChannelQueueType

+ const DummyQueueType

+ const LevelQueueType

+ const PersistableChannelQueueType

+ const RedisQueueType

+ const WrappedQueueType

+ func RegisteredTypes() []Type

+ type WorkerPool struct

+ func (p *WorkerPool) AddWorkers(number int, timeout time.Duration) context.CancelFunc

+ func (p *WorkerPool) BlockTimeout() time.Duration

+ func (p *WorkerPool) BoostTimeout() time.Duration

+ func (p *WorkerPool) BoostWorkers() int

+ func (p *WorkerPool) CleanUp(ctx context.Context)

+ func (p *WorkerPool) MaxNumberOfWorkers() int

+ func (p *WorkerPool) NumberOfWorkers() int

+ func (p *WorkerPool) Push(data Data)

+ func (p *WorkerPool) SetMaxNumberOfWorkers(newMax int)

+ func (p *WorkerPool) SetSettings(maxNumberOfWorkers, boostWorkers int, timeout time.Duration)

+ func (p *WorkerPool) Wait()

+ type WrappedQueue struct

+ func (q *WrappedQueue) Name() string

+ func (q *WrappedQueue) Push(data Data) error

+ func (q *WrappedQueue) Run(atShutdown, atTerminate func(context.Context, func()))

+ func (q *WrappedQueue) Shutdown()

+ func (q *WrappedQueue) Terminate()

+ type WrappedQueueConfiguration struct

+ Config interface{}

+ MaxAttempts int

+ Name string

+ QueueLength int

+ Timeout time.Duration

+ Underlying Type