Package EventBus is the little and lightweight eventbus with async compatibility for GoLang.

Make sure that Go is installed on your computer. Type the following command in your terminal:

go get github.com/asaskevich/EventBus

After it the package is ready to use.

Add following line in your *.go file:

import "github.com/asaskevich/EventBus"

If you unhappy to use long EventBus, you can do something like this:

import (
	evbus "github.com/asaskevich/EventBus"
)

func calculator(a int, b int) {
	fmt.Printf("%d\n", a + b)
}

func main() {
	bus := EventBus.New();
	bus.Subscribe("main:calculator", calculator);
	bus.Publish("main:calculator", 20, 40);
	bus.Unsubscribe("main:calculator", calculator);
}

• New()
• Subscribe()
• SubscribeOnce()
• HasCallback()
• Unsubscribe()
• Publish()
• SubscribeAsync()
• SubscribeOnceAsync()
• SubscribeReplyAsync()
• Request()
• WaitAsync()

New returns new EventBus with empty handlers.

bus := EventBus.New();

Subscribe to a topic. Returns error if fn is not a function.

func Handler() { ... }
...
bus.Subscribe("topic:handler", Handler)

Subscribe to a topic once. Handler will be removed after executing. Returns error if fn is not a function.

func HelloWorld() { ... }
...
bus.SubscribeOnce("topic:handler", HelloWorld)

Remove callback defined for a topic. Returns error if there are no callbacks subscribed to the topic.

bus.Unsubscribe("topic:handler", HelloWord);

Returns true if exists any callback subscribed to the topic.

Publish executes callback defined for a topic. Any additional argument will be transferred to the callback.

func Handler(str string) { ... }
...
bus.Subscribe("topic:handler", Handler)
...
bus.Publish("topic:handler", "Hello, World!");

Subscribe to a topic with an asynchronous callback. Returns error if fn is not a function.

func slowCalculator(a, b int) {
	time.Sleep(3 * time.Second)
	fmt.Printf("%d\n", a + b)
}

bus := EventBus.New()
bus.SubscribeAsync("main:slow_calculator", slowCalculator, false)

bus.Publish("main:slow_calculator", 20, 60)

fmt.Println("start: do some stuff while waiting for a result")
fmt.Println("end: do some stuff while waiting for a result")

bus.WaitAsync() // wait for all async callbacks to complete

fmt.Println("do some stuff after waiting for result")

Transactional determines whether subsequent callbacks for a topic are run serially (true) or concurrently(false)

SubscribeOnceAsync works like SubscribeOnce except the callback to executed asynchronously

SubscribeReplyAsync works like SubscribeAsync except the callback is expected to return a value. The value is returned to the caller of Publish.

Request is a function that allows you to make a request to a topic and wait for a response. The response is returned to the caller of Request as an interface{}.

bus := EventBus.New()

func slowCalculator(reply string, a, b int) {
    time.Sleep(3 * time.Second)
    bus.Publish(reply, a + b)
}

bus.SubscribeReplyAsync("main:slow_calculator", slowCalculator)

reply := bus.Request("main:slow_calculator", func(rslt int) {
    fmt.Printf("Result: %d\n", rslt)
}, 20, 60)

WaitAsync waits for all async callbacks to complete.

Works with two rpc services:

• a client service to listen to remotely published events from a server
• a server service to listen to client subscriptions

server.go

func main() {
    server := NewServer(":2010", "/_server_bus_", New())
    server.Start()
    // ...
    server.EventBus().Publish("main:calculator", 4, 6)
    // ...
    server.Stop()
}

client.go

func main() {
    client := NewClient(":2015", "/_client_bus_", New())
    client.Start()
    client.Subscribe("main:calculator", calculator, ":2010", "/_server_bus_")
    // ...
    client.Stop()
}

Documentation is available here: godoc.org. Full information about code coverage is also available here: EventBus on gocover.io.

If you do have a contribution for the package feel free to put up a Pull Request or open Issue.

• Brian Downs
• Dominik Schulz
• bennAH
• [John Noble] (https://github.com/gaxunil)
• [Evan Borgstrom] (https://github.com/borgstrom)