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 ids.ID) *ErrUnhandledEvent
  • func (e ErrUnhandledEvent) Error() string
• type Event
• type EventBus
• type EventConsumer
• type EventEnvelope
  • func (e *EventEnvelope) ProcessOptions(options []Option)
• type EventName
• 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   ids.ID
}

func NewErrUnhandledEvent

func NewErrUnhandledEvent(eventName string, eventId ids.ID) *ErrUnhandledEvent

func (ErrUnhandledEvent) Error

func (e ErrUnhandledEvent) Error() string

type Event

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

type EventBus

type EventBus interface {
	Start() error
	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 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