kernel

type Bridge ¶ added in v0.20.0

type Bridge struct {
	// contains filtered or unexported fields
}

Bridge Lambda's main function to Listener interface Bridge is single threaded and should be used in the context of Lambda handler only.

Bridge implements Ask interface for the Lambda handler to receive messages. Dispatch and Ask & Ack are corner stones for this adapter. Dispatch blocks until all messages are Asked and Acked by the kernel.

func NewBridge(cfg swarm.Config) *Bridge

func (s *Bridge) Ack(ctx context.Context, digest swarm.Digest) error

func (s *Bridge) Ask(ctx context.Context) ([]swarm.Bag, error)

func (s *Bridge) Close() error

func (s *Bridge) Dispatch(ctx context.Context, seq []swarm.Bag) error

lambda.Start(
	func(evt events.CloudWatchEvent) error {
		...
		bridge.Dispatch(bag)
	}
)

func (s *Bridge) Err(ctx context.Context, digest swarm.Digest, err error) error

type Decoder ¶ added in v0.20.0

type Decoder[T any] interface {
	Category() string
	Decode(swarm.Bag) (T, error)
}

Decode message from wire format

type Emitter ¶

type Emitter interface {
	Enq(context.Context, swarm.Bag) error
	Close() error
}

Emitter defines on-the-wire protocol for swarm.Bag, covering egress use-cases

type EmitterIO ¶ added in v0.24.0

type EmitterIO struct {
	sync.WaitGroup

	// Kernel configuration
	Config swarm.Config

	// Emitter is the writer port on message broker
	Emitter Emitter
	// contains filtered or unexported fields
}

The egress part of the kernel is used to enqueue messages into message broker.

func NewEmitter(emitter Emitter, config swarm.Config) *EmitterIO

func (k *EmitterIO) Await()

func (k *EmitterIO) Close()

type Encoder ¶ added in v0.20.0

type Encoder[T any] interface {
	Category() string
	Encode(T) (swarm.Bag, error)
}

Encodes message into wire format

type Kernel ¶

type Kernel struct {
	Emitter  *EmitterIO
	Listener *ListenerIO
}

func New(emitter *EmitterIO, listener *ListenerIO) *Kernel

func (k *Kernel) Await()

func (k *Kernel) Close()

type Listener ¶ added in v0.23.0

type Listener interface {
	Ack(ctx context.Context, digest swarm.Digest) error
	Err(ctx context.Context, digest swarm.Digest, err error) error
	Ask(ctx context.Context) ([]swarm.Bag, error)
	Close() error
}

Listener defines on-the-wire protocol for swarm.Bag, covering the ingress use-cases.

type ListenerIO ¶ added in v0.24.0

type ListenerIO struct {
	sync.WaitGroup
	sync.RWMutex

	// Kernel configuration
	Config swarm.Config

	// Listener is the reader port on message broker
	Listener Listener
	// contains filtered or unexported fields
}

The ingress part of the kernel is used to dequeue messages from message broker.

func NewListener(listener Listener, config swarm.Config) *ListenerIO

func (k *ListenerIO) Await()

func (k *ListenerIO) Close()

type Router ¶ added in v0.20.0

type Router = interface {
	Route(context.Context, swarm.Bag) error
}

Routes messages from the ingress to the destination channel.