async

Documentation

Index

• Variables
• type Func
• type Group
  • func GroupFunc[T any](size int, handlerFunc HandlerFunc[T], canHandle SelectorFunc[T]) Group[T]
• type HandlerFunc
• type PollerFunc
• type Pool
  • func NewPool[T any](logger log.Logger, puller Puller[T], groups ...Group[T]) Pool[T]
• type PoolContext
• type Puller
  • func Poll[T any](interval time.Duration, pollFn PollerFunc[T]) Puller[T]
• type SelectorFunc

Variables

var ErrAlreadyStarted = errors.New("already_started")

Types

type Func

type Func func(<-chan bool) // Async function run by the pool

type Group

type Group[T any] interface {
	OnStart(PoolContext[T])         // Called upon pool startup, use PoolContext.Run to register a goroutine
	Handle(context.Context, T) bool // Try to handle the given job, returns true if the job was handled, false otherwise
}

Async group of runners which can actually handle jobs.

func GroupFunc

func GroupFunc[T any](size int, handlerFunc HandlerFunc[T], canHandle SelectorFunc[T]) Group[T]

Builds a new runners group which will process jobs satisfying the canHandle function.

type HandlerFunc

type HandlerFunc[T any] func(context.Context, T) error // Process a single job

type PollerFunc

type PollerFunc[T any] func(context.Context) ([]T, error)

type Pool

type Pool[T any] interface {
	Start() error // Start the pool
	Stop()        // Wait for the current pool to complete running jobs and returns
}

Represents an asynchronous pool which can process multiple jobs simultaneously.

func NewPool

func NewPool[T any](
	logger log.Logger,
	puller Puller[T],
	groups ...Group[T],
) Pool[T]

Builds a new pool with a specific Puller to feed registered groups with actual jobs to process.

The idea behind groups is that some jobs need more time to complete and I don't want to hold back the other ones such as (in the future), sending emails, checking stuff, etc.

type PoolContext

type PoolContext[T any] interface {
	Queue(context.Context, ...T) // Queue one or multiple jobs to be processed
	Logger() log.Logger          // Returns the logger used by the pool
	Run(Func)                    // Launch a function in a new goroutine which MUST listen for the done signal and exit when it receives it
}

Pool context as seen by puller, groups and internal stuff.

type Puller

type Puller[T any] interface {
	OnStart(PoolContext[T]) // Called upon pool startup, use PoolContext.Run to register a goroutine
}

Puller interface used to retrieve jobs to process from somewhere.

func Poll

func Poll[T any](interval time.Duration, pollFn PollerFunc[T]) Puller[T]

Simple puller wich will call the given function at the given interval.

type SelectorFunc

type SelectorFunc[T any] func(context.Context, T) bool // Returns true if the group can handle the job