ezbus

README

go-ezbus

This is a package for communication between services in a distrubuted architecture. Using RabbitMQ as transport for messages.

pub/sub pattern

                                       subscriber a
                                      /
                                     /
                                    /
command ----> publisher -- event --> subscriber b
                                    \
                                     \
                                      \
                                       subscriber c 

code example

type PlaceOrder struct {
	ID string
}

type OrderPlaced struct {
	ID string
}

r := ezbus.NewRouter()
r.Handle("placeOrder", func(message) {
    PlaceOrder po
    json.Unmarshal(m.Body, &po) 
    bus.Publish(OrderPlaced {po.ID})
})

b := ezbus.NewBroker("my.queue");
bus := ezbus.NewBus(b, r)

bus.Go()

Documentation

Index

• type Broker
• type Bus
  • func NewBus(b Broker, r Router) Bus
• 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

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 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)

MessageHandler func for handling messsages

type Middleware

type Middleware = func(next MessageHandler) MessageHandler

Middleware for router message handling

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)
}

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