ezbus

README

go-ezbus

This is a package for communication between software components. It makes sending, publishing and receiving messages super easy!

Using RabbitMQ as transport for messages. More transports can and will (hopefully) be added

install

go get github.com/zapote/go-ezbus

idea

Ezbus is great to use when working in a distrubuted system. Publish events when a software executes a command and let rest of the system know.

Plugin new software components in your architecture without touching the existing ones.

Ezbus is super easy to use and will get you started in no time.

code example

//PlaceOrder command
type PlaceOrder struct {
	ID string
}

//OrderPlaced event
type OrderPlaced struct {
	ID string
}

//create message router
r := ezbus.NewRouter()

//register handler for message PlaceOrder
r.Handle("PlaceOrder", func(message ezbus.Message) {
    var po PlaceOrder
    json.Unmarshal(m.Body, &po) 
    bus.Publish(OrderPlaced {po.ID})
})

//create a rabbitmq broker
b := rabbitmq.NewBroker("my-queue");

//create the bus with router and broker
bus := ezbus.NewBus(b, r)

//Go!
bus.Go()

Documentation

Index

• func IsHandlerNotFoundErr(err error) bool
• type Broker
• type Bus
  • func NewBus(b Broker, r Router) Bus
• type HandlerNotFoundErr
  • func (e HandlerNotFoundErr) Error() string
• type Message
  • func NewMessage(h map[string]string, b []byte) Message
• type MessageHandler
• type Middleware
• type Publisher
• type Router
  • func NewRouter() Router
• type Sender
• type StarterStopper
• type Subscriber

Functions

func IsHandlerNotFoundErr

func IsHandlerNotFoundErr(err error) bool

IsHandlerNotFoundErr checks if error is HandlerNotFoundErr

Types

type Broker

type Broker interface {
	Send(dst string, m Message) error
	Publish(m Message) error
	Start(handle MessageHandler) error
	Stop() error
	Endpoint() string
	Subscribe(endpoint string, messageName string) error
}

Broker interface

type Bus

type Bus interface {
	StarterStopper
	Sender
	Publisher
	Subscriber
}

Bus for publishing, sending and receiving messages

func NewBus

func NewBus(b Broker, r Router) Bus

NewBus creates a bus instance for sending and receiving messages.

type HandlerNotFoundErr

type HandlerNotFoundErr struct {
	MessageName string
}

HandlerNotFoundErr is returned when handler is not found

func (HandlerNotFoundErr) Error

func (e HandlerNotFoundErr) Error() string

type Message

type Message struct {
	Headers map[string]string
	Body    []byte
}

Message in EzBus

func NewMessage

func NewMessage(h map[string]string, b []byte) Message

NewMessage creates a new Message instance Using h as headers and b as body

type MessageHandler

type MessageHandler = func(m Message) error

MessageHandler func for handling messsages

type Middleware

type Middleware = func(next MessageHandler) MessageHandler

Middleware for router message handling pipeline

type Publisher

type Publisher interface {
	Publish(msg interface{}) error
}

Publisher interface

type Router

type Router interface {
	Handle(messageName string, h MessageHandler)
	Middleware(mw Middleware)
	Receive(n string, m Message) error
}

Router routes message to correct MessageHandler func

func NewRouter

func NewRouter() Router

NewRouter creates a new router instance.

type Sender

type Sender interface {
	Send(dst string, msg interface{}) error
}

Sender interface

type StarterStopper

type StarterStopper interface {
	Go() error
	Stop() error
}

StarterStopper interface

type Subscriber

type Subscriber interface {
	Subscribe(endpoint string)
	SubscribeMessage(endpoint string, messageName string)
}

Subscriber interface