ezbus

README

go-ezbus

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

pub/sub pattern

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

code example

r := ezbus.NewRouter()
r.Handle("placeOrder", func(message) {
    bus.publish(OrderPlaced {ID:"123", Number=1000})
})

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

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 Receiver
• type Router
  • func NewRouter() Router
• type Sender
• type Subscriber

Types

type Broker

type Broker interface {
	Sender
	Publisher
	Receiver
	Subscriber
}

Broker interface

type Bus

type Bus interface {
	Go()
	Stop()
	Send(dst string, msg interface{}) error
	Publish(msg interface{}) error
	Subscribe(endpoint string)
	SubscribeMessage(endpoint string, messageName string)
}

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(m Message) error
}

Publisher interface

type Receiver

type Receiver interface {
	Start(handle MessageHandler) error
	Stop() error
	Endpoint() string
}

Receiver 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, m Message) error
}

Sender interface

type Subscriber

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

Subscriber interface