eventbus

Documentation

Index

• func Subscribe[T Event](subscriber Subscriber, eventName EventName, handler TypedEventHandler[T]) error
• type Callback
• type Event
• type EventBus
• type EventEnvelope
  • func (e *EventEnvelope) ProcessOptions(options []Option)
• type EventHandler
• type EventName
• type Option
  • func WithAck(callback Callback) Option
  • func WithContext(ctx context.Context) Option
  • func WithWait() Option
• type Publisher
• type Subscriber
• type TypedEventHandler

Functions

func Subscribe

func Subscribe[T Event](subscriber Subscriber, eventName EventName, handler TypedEventHandler[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 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 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 EventHandler

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

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 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 handler will be called when the event is published.
	// The handler can return an error, which will be returned by the Publish method.
	Subscribe(eventName EventName, handler EventHandler) error
}

type TypedEventHandler

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