jazz alternatives and similar packages
Based on the "Messaging" category.
Alternatively, view jazz alternatives based on common mentions on social networks and blogs.
-
NATS Go Client
A lightweight and high performance publish-subscribe and distributed queueing messaging system -
Confluent Kafka Golang Client
confluent-kafka-go is Confluent's Golang client for Apache Kafka and the Confluent Platform. -
NATS
A lightweight and highly performant publish-subscribe and distributed queueing messaging system. -
Mercure
Server and library to dispatch server-sent updates using the Mercure protocol (built on top of Server-Sent Events). -
Gollum
A n:m multiplexer that gathers messages from different sources and broadcasts them to a set of destinations. -
mangos
Pure go implementation of the Nanomsg ("Scalable Protocols") with transport interoperability. -
emitter
Emits events using Go way, with wildcard, predicates, cancellation possibilities and many other good wins. -
messagebus
messagebus is a Go simple async message bus, perfect for using as event bus when doing event sourcing, CQRS, DDD. -
guble
A messaging server using push notifications (Google Firebase Cloud Messaging, Apple Push Notification services, SMS) as well as websockets, a REST API, featuring distributed operation and message-persistence. -
go-res
Package for building REST/real-time services where clients are synchronized seamlessly, using NATS and Resgate. -
Commander
A high-level event driven consumer/producer supporting various "dialects" such as Apache Kafka. -
rmqconn
RabbitMQ Reconnection. Wrapper over amqp.Connection and amqp.Dial. Allowing to do a reconnection when the connection is broken before forcing the call to the Close () method to be closed.
Get performance insights in less than 4 minutes
Do you think we are missing an alternative of jazz or a related project?
Popular Comparisons
README
Jazz
Abstraction layer for quick and simple rabbitMQ connection, messaging and administration. Inspired by Jazz Jackrabbit and his eternal hatred towards slow turtles.
Usage
This library contains three major parts - exchange/queue scheme creation, publishing of messages and consuming of messages. The greatest benefit of this partitioning is that each part might be in separate application. Also due to dedicated administration part, publishing and consuming of messages is simplified to great extent.
Step 1: Connect to rabbit
import(
"github.com/socifi/jazz"
)
var dsn = "amqp://guest:[email protected]:5672/"
func main() {
// ...
c, err := jazz.Connect(dsn)
if err != nil {
t.Errorf("Could not connect to RabbitMQ: %v", err.Error())
return
}
//...
}
Step 2: Create scheme
Scheme specification is done via structure Settings
which can be easily specified in YAML. So generally you need to decode YAML and then create all queues and exchanges
It can be something really crazy like this!
var data = []byte(`
exchanges:
exchange0:
durable: true
type: topic
exchange1:
durable: true
type: topic
bindings:
- exchange: "exchange0"
key: "key1"
- exchange: "exchange0"
key: "key2"
exchange2:
durable: true
type: topic
bindings:
- exchange: "exchange0"
key: "key3"
- exchange: "exchange1"
key: "key2"
exchange3:
durable: true
type: topic
bindings:
- exchange: "exchange0"
key: "key4"
queues:
queue0:
durable: true
bindings:
- exchange: "exchange0"
key: "key4"
queue1:
durable: true
bindings:
- exchange: "exchange1"
key: "key2"
queue2:
durable: true
bindings:
- exchange: "exchange1"
key: "#"
queue3:
durable: true
bindings:
- exchange: "exchange2"
key: "#"
queue4:
durable: true
bindings:
- exchange: "exchange3"
key: "#"
queue5:
durable: true
bindings:
- exchange: "exchange0"
key: "#"
`)
func main() {
// ...
reader := bytes.NewReader(data)
scheme, err := DecodeYaml(reader)
if err != nil {
t.Errorf("Could not read YAML: %v", err.Error())
return
}
err = c.CreateScheme(scheme)
if err != nil {
t.Errorf("Could not create scheme: %v", err.Error())
return
}
//...
// Be nice and delete scheme (Not advisable in ).
err = c.DeleteScheme(scheme)
if err != nil {
t.Errorf("Could not delete scheme: %v", err.Error())
return
}
}
Step 3: Publish and/or consume messages
You can process each queue in separate application or everything together like this:
func main() {
// ...
f := func(msg []byte) {
fmt.Println(string(msg))
}
go c.ProcessQueue("queue1", f)
go c.ProcessQueue("queue2", f)
go c.ProcessQueue("queue3", f)
go c.ProcessQueue("queue4", f)
go c.ProcessQueue("queue5", f)
go c.ProcessQueue("queue6", f)
c.SendMessage("exchange0", "key1", "Hello World!")
c.SendMessage("exchange0", "key2", "Hello!")
c.SendMessage("exchange0", "key3", "World!")
c.SendMessage("exchange0", "key4", "Hi!")
c.SendMessage("exchange0", "key5", "Again!")
//...
}
Notes
No copyright infringement intended. The name Jazz Jackrabbit and artwork of Jazz Jackrabbit is intelectual property of Epic MegaGames and was taken over from wikipedia