eventbus

Documentation

Index

• Variables
• func Subscribe[T Event](subscriber Subscriber, eventName EventName, handler TypedEventConsumer[T]) error
• type Callback
• type ErrUnhandledEvent
  • func NewErrUnhandledEvent(eventName string, eventId uuid.UUID) *ErrUnhandledEvent
  • func (e ErrUnhandledEvent) Error() string
• type Event
• type EventBus
• type EventConsumer
• type EventEnvelope
  • func (e *EventEnvelope) ProcessOptions(options []Option)
• type EventName
• type LifeCycleListener
• type LifeCycleProvider
• type Option
  • func WithAck(callback Callback) Option
  • func WithAckChan(ch chan<- error) Option
  • func WithContext(ctx context.Context) Option
  • func WithWait() Option
• type Publisher
• type Subscriber
• type TypedEventConsumer

Variables

var (
	// ErrEmptyEventName is returned when an empty event name is provided while subscribing.
	ErrEmptyEventName = errors.New("event name cannot be empty")
	// ErrBusNotRunning is returned when an operation is performed on a localBus that is not running.
	ErrBusNotRunning = errors.New("bus is not running")
	// ErrBusAlreadyRunning is returned when the localBus is already running.
	ErrBusAlreadyRunning = errors.New("bus is already running")
)

Functions

func Subscribe

func Subscribe[T Event](subscriber Subscriber, eventName EventName, handler TypedEventConsumer[T]) error

Subscribe subscribes to an event of a given type. It allows to use a typed handler.

Types

type Callback

type Callback func(event Event, err error)

Callback is a callback function that is called when an event is processed by the listener.

type ErrUnhandledEvent

type ErrUnhandledEvent struct {
	EventName string
	EventId   uuid.UUID
}

func NewErrUnhandledEvent

func NewErrUnhandledEvent(eventName string, eventId uuid.UUID) *ErrUnhandledEvent

func (ErrUnhandledEvent) Error

func (e ErrUnhandledEvent) Error() string

type Event

type Event interface {
	// ID returns the ID of the event.
	ID() uuid.UUID
	// Name returns the name of the event.
	Name() EventName
}

type EventBus

type EventBus interface {
	// Start starts the event bus to process events.
	Start() error
	// Stop stops the event bus.
	Stop() error

	Publisher
	Subscriber
}

EventBus allows to publish and subscribe to events. It is a simple interface that allows to decouple the event publishing from the event handling. The handler can return an error, which will be returned by the Publish method. The publisher can publish as fire-and-forget, or wait for the handler to confirm the processing (replyHandler).

type EventConsumer

type EventConsumer func(ctx context.Context, event Event) error

type EventEnvelope

type EventEnvelope struct {
	Event      Event
	Err        error
	Ctx        context.Context
	Callback   Callback
	ShouldWait bool
}

EventEnvelope is a wrapper around the event that is sent to the bus. It holds other information that is used by the bus to process the event.

func (*EventEnvelope) ProcessOptions

func (e *EventEnvelope) ProcessOptions(options []Option)

ProcessOptions processes the options and sets the values on the envelope.

type EventName

type EventName = string

type LifeCycleListener

type LifeCycleListener interface {
	OnStart(ctx context.Context)
	OnStop()
}

type LifeCycleProvider

type LifeCycleProvider interface {
	// AddLifecycleListener adds a listener that is called when the bus is started or stopped.
	AddLifecycleListener(listener LifeCycleListener)
}

LifeCycleProvider is implemented by buses that allows to add a listener that is called when the bus is started or stopped.

type Option

type Option func(*EventEnvelope)

func WithAck

func WithAck(callback Callback) Option

WithAck sets the callback function that is called when the event is processed.

func WithAckChan

func WithAckChan(ch chan<- error) Option

func WithContext

func WithContext(ctx context.Context) Option

func WithWait

func WithWait() Option

WithWait sets the flag that indicates that the event should be processed synchronously.

type Publisher

type Publisher interface {
	// Publish publishes an event. Methods can return before the Event is handled.
	Publish(event Event, options ...Option) error
}

type Subscriber

type Subscriber interface {
	// Subscribe subscribes to an event.
	// The consumer will be called when the event is published.
	// The consumer can return an error, which will be returned by the Publish method.
	Subscribe(eventName EventName, consumer EventConsumer) error
}

type TypedEventConsumer

type TypedEventConsumer[T Event] func(ctx context.Context, event T) error