keyed

Documentation

Index

• func NewLogExitedCallback[K comparable, V any](le *logrus.Entry) func(key K, routine Routine, data V, err error)
• type KeyWithData
• type Keyed
  • func NewKeyed[K comparable, V any](ctorCb func(key K) (Routine, V), opts ...Option[K, V]) *Keyed[K, V]
  • func NewKeyedWithLogger[K comparable, V any](ctorCb func(key K) (Routine, V), le *logrus.Entry) *Keyed[K, V]
  • func (k *Keyed[K, V]) ClearContext()
  • func (k *Keyed[K, V]) GetKey(key K) (V, bool)
  • func (k *Keyed[K, V]) GetKeys() []K
  • func (k *Keyed[K, V]) GetKeysWithData() []KeyWithData[K, V]
  • func (k *Keyed[K, V]) RemoveKey(key K) bool
  • func (k *Keyed[K, V]) ResetRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)
  • func (k *Keyed[K, V]) RestartRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)
  • func (k *Keyed[K, V]) SetContext(ctx context.Context, restart bool)
  • func (k *Keyed[K, V]) SetContextIfCanceled(ctx context.Context, restart bool) bool
  • func (k *Keyed[K, V]) SetKey(key K, start bool) (V, bool)
  • func (k *Keyed[K, V]) SyncKeys(keys []K, restart bool)
• type KeyedRef
  • func (k *KeyedRef[K, V]) Release()
• type KeyedRefCount
  • func NewKeyedRefCount[K comparable, V any](ctorCb func(key K) (Routine, V), opts ...Option[K, V]) *KeyedRefCount[K, V]
  • func NewKeyedRefCountWithLogger[K comparable, V any](ctorCb func(key K) (Routine, V), le *logrus.Entry) *KeyedRefCount[K, V]
  • func (k *KeyedRefCount[K, V]) AddKeyRef(key K) (ref *KeyedRef[K, V], data V, existed bool)
  • func (k *KeyedRefCount[K, V]) ClearContext()
  • func (k *KeyedRefCount[K, V]) GetKey(key K) (V, bool)
  • func (k *KeyedRefCount[K, V]) GetKeys() []K
  • func (k *KeyedRefCount[K, V]) GetKeysWithData() []KeyWithData[K, V]
  • func (k *KeyedRefCount[K, V]) ResetRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)
  • func (k *KeyedRefCount[K, V]) RestartRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)
  • func (k *KeyedRefCount[K, V]) SetContext(ctx context.Context, restart bool)
  • func (k *KeyedRefCount[K, V]) SetContextIfCanceled(ctx context.Context, restart bool) bool
• type Option
  • func WithExitCb[K comparable, V any](cb func(key K, routine Routine, data V, err error)) Option[K, V]
  • func WithExitLogger[K comparable, V any](le *logrus.Entry) Option[K, V]
  • func WithReleaseDelay[K comparable, V any](delay time.Duration) Option[K, V]
  • func WithRetry[K comparable, V any](bo *backoff.Backoff) Option[K, V]
• type Routine

Functions

func NewLogExitedCallback

func NewLogExitedCallback[K comparable, V any](le *logrus.Entry) func(key K, routine Routine, data V, err error)

NewLogExitedCallback returns a ExitedCb which logs when a controller exited.

Types

type KeyWithData

type KeyWithData[K comparable, V any] struct {
	// Key is the key.
	Key K
	// Data is the value.
	Data V
}

KeyWithData is a key with associated data.

type Keyed

type Keyed[K comparable, V any] struct {
	// contains filtered or unexported fields
}

Keyed manages a set of goroutines with associated Keys.

K is the type of the key. V is the type of the value.

func NewKeyed

func NewKeyed[K comparable, V any](
	ctorCb func(key K) (Routine, V),
	opts ...Option[K, V],
) *Keyed[K, V]

NewKeyed constructs a new Keyed execution manager. Note: routines won't start until SetContext is called.

func NewKeyedWithLogger

func NewKeyedWithLogger[K comparable, V any](
	ctorCb func(key K) (Routine, V),
	le *logrus.Entry,
) *Keyed[K, V]

NewKeyedWithLogger constructs a new keyed instance. Logs when a controller exits without being removed from the Keys set.

Note: routines won't start until SetContext is called.

func (*Keyed[K, V]) ClearContext

func (k *Keyed[K, V]) ClearContext()

ClearContext clears the context and shuts down any running routines.

func (*Keyed[K, V]) GetKey

func (k *Keyed[K, V]) GetKey(key K) (V, bool)

GetKey returns the value for the given key and existed.

func (*Keyed[K, V]) GetKeys

func (k *Keyed[K, V]) GetKeys() []K

GetKeys returns the list of keys registered with the Keyed instance.

func (*Keyed[K, V]) GetKeysWithData

func (k *Keyed[K, V]) GetKeysWithData() []KeyWithData[K, V]

GetKeysWithData returns the keys and the data for the keys.

func (*Keyed[K, V]) RemoveKey

func (k *Keyed[K, V]) RemoveKey(key K) bool

RemoveKey removes the given key from the set, if it exists. Returns if it existed.

func (*Keyed[K, V]) ResetRoutine

func (k *Keyed[K, V]) ResetRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)

ResetRoutine resets the given routine after checking the condition functions. If any of the conds functions return true, resets the instance.

Resetting the instance constructs a new Routine and data with the constructor. Note: this will overwrite the existing Data, if present! In most cases RestartRoutine is actually what you want.

If len(conds) == 0, always resets the given key.

func (*Keyed[K, V]) RestartRoutine

func (k *Keyed[K, V]) RestartRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)

RestartRoutine restarts the given routine after checking the condition functions. If any return true, and the routine is running, restarts the instance.

If len(conds) == 0, always resets the given key.

func (*Keyed[K, V]) SetContext

func (k *Keyed[K, V]) SetContext(ctx context.Context, restart bool)

SetContext updates the root context, restarting all running routines.

nil context is valid and will shutdown the routines. if restart is true, all errored routines also restart

func (*Keyed[K, V]) SetContextIfCanceled

func (k *Keyed[K, V]) SetContextIfCanceled(ctx context.Context, restart bool) bool

SetContextIfCanceled updates the context to use for the keyed container resolution. If the current r.ctx is not nil and not canceled, does nothing. If the passed ctx is nil or canceled, does nothing. if restart is true, all errored routines also restart Returns if the context was updated.

func (*Keyed[K, V]) SetKey

func (k *Keyed[K, V]) SetKey(key K, start bool) (V, bool)

SetKey inserts the given key into the set, if it doesn't already exist. If start=true, restarts the routine from any stopped or failed state. Returns if it existed already or not.

func (*Keyed[K, V]) SyncKeys

func (k *Keyed[K, V]) SyncKeys(keys []K, restart bool)

SyncKeys synchronizes the list of running routines with the given list. If restart=true, restarts any routines in the failed state.

type KeyedRef

type KeyedRef[K comparable, V any] struct {
	// contains filtered or unexported fields
}

KeyedRef is a reference to a key.

func (*KeyedRef[K, V]) Release

func (k *KeyedRef[K, V]) Release()

Release releases the reference.

type KeyedRefCount

type KeyedRefCount[K comparable, V any] struct {
	// contains filtered or unexported fields
}

KeyedRefCount manages a list of running routines with reference counts.

func NewKeyedRefCount

func NewKeyedRefCount[K comparable, V any](
	ctorCb func(key K) (Routine, V),
	opts ...Option[K, V],
) *KeyedRefCount[K, V]

NewKeyedRefCount constructs a new Keyed execution manager with reference counting. Note: routines won't start until SetContext is called.

func NewKeyedRefCountWithLogger

func NewKeyedRefCountWithLogger[K comparable, V any](
	ctorCb func(key K) (Routine, V),
	le *logrus.Entry,
) *KeyedRefCount[K, V]

NewKeyedRefCountWithLogger constructs a new Keyed execution manager with reference counting. Logs when a controller exits without being removed from the Keys set. Note: routines won't start until SetContext is called.

func (*KeyedRefCount[K, V]) AddKeyRef

func (k *KeyedRefCount[K, V]) AddKeyRef(key K) (ref *KeyedRef[K, V], data V, existed bool)

AddKeyRef adds a reference to the given key. Returns if the key already existed or not.

func (*KeyedRefCount[K, V]) ClearContext

func (k *KeyedRefCount[K, V]) ClearContext()

ClearContext clears the context and shuts down all routines.

func (*KeyedRefCount[K, V]) GetKey

func (k *KeyedRefCount[K, V]) GetKey(key K) (V, bool)

GetKey returns the value for the given key and if it existed.

func (*KeyedRefCount[K, V]) GetKeys

func (k *KeyedRefCount[K, V]) GetKeys() []K

GetKeys returns the list of keys registered with the Keyed instance.

func (*KeyedRefCount[K, V]) GetKeysWithData

func (k *KeyedRefCount[K, V]) GetKeysWithData() []KeyWithData[K, V]

GetKeysWithData returns the keys and the data for the keys.

func (*KeyedRefCount[K, V]) ResetRoutine

func (k *KeyedRefCount[K, V]) ResetRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)

ResetRoutine resets the given routine after checking the condition functions. If any return true, resets the instance.

If len(conds) == 0, always resets the given key.

func (*KeyedRefCount[K, V]) RestartRoutine

func (k *KeyedRefCount[K, V]) RestartRoutine(key K, conds ...func(V) bool) (existed bool, reset bool)

RestartRoutine restarts the given routine after checking the condition functions. If any return true, and the routine is running, restarts the instance.

If len(conds) == 0, always resets the given key.

func (*KeyedRefCount[K, V]) SetContext

func (k *KeyedRefCount[K, V]) SetContext(ctx context.Context, restart bool)

SetContext updates the root context, restarting all running routines. if restart is true, all errored routines also restart

nil context is valid and will shutdown the routines.

func (*KeyedRefCount[K, V]) SetContextIfCanceled

func (k *KeyedRefCount[K, V]) SetContextIfCanceled(ctx context.Context, restart bool) bool

SetContextIfCanceled updates the context to use for the keyed container resolution. If the current r.ctx is not nil and not canceled, does nothing. If the passed ctx is nil or canceled, does nothing. if restart is true, all errored routines also restart Returns if the context was updated.

type Option

type Option[K comparable, V any] interface {
	// ApplyToKeyed applies the option to the Keyed.
	ApplyToKeyed(k *Keyed[K, V])
}

Option is an option for a Keyed instance.

func WithExitCb

func WithExitCb[K comparable, V any](cb func(key K, routine Routine, data V, err error)) Option[K, V]

WithExitCb adds a callback after a routine exits.

func WithExitLogger

func WithExitLogger[K comparable, V any](le *logrus.Entry) Option[K, V]

WithExitLogger adds a exited callback which logs information about the exit.

func WithReleaseDelay

func WithReleaseDelay[K comparable, V any](delay time.Duration) Option[K, V]

WithReleaseDelay adds a delay after removing a key before canceling the routine.

func WithRetry

func WithRetry[K comparable, V any](bo *backoff.Backoff) Option[K, V]

WithRetry adds a retry after a routine exits with an error.

If the backoff config is nil, disables retry.

type Routine

type Routine func(ctx context.Context) error

Routine is a function called as a goroutine. If nil is returned, exits cleanly permanently. If an error is returned, can be restarted later.