Go client to reliable queues based on Redis Cluster Streams.

# Ami

Go client to reliable queues based on [Redis Cluster Streams](https://redis.io/topics/streams-intro).

[![Godoc](https://godoc.org/github.com/kak-tus/ami?status.svg)](http://godoc.org/github.com/kak-tus/ami)
[![Coverage Status](https://coveralls.io/repos/github/kak-tus/ami/badge.svg)](https://coveralls.io/github/kak-tus/ami)
[![Go Report Card](https://goreportcard.com/badge/github.com/kak-tus/ami)](https://goreportcard.com/report/github.com/kak-tus/ami)
![Go](https://github.com/kak-tus/ami/workflows/Go/badge.svg)

## Consume/produce performance

Performance is dependent from:
- Redis Cluster nodes count;
- ping RTT from client to Redis Cluster master nodes;
- network speed between nodes;
- message sizes;
- Ami configuration.

As example, 10-nodes Redis Cluster with half of nodes in other datacenter (50 msec ping), 1 master/1 slave, with message "{}" got:
```
$ go run examples/performance/main.go
Produced 1000000 in 3.423883 sec, rps 292066.022156
Consumed 151000 in 1.049238 sec, rps 143913.931722
Acked 151000 in 0.973587 sec, rps 155096.612263
```

## Producer example

```
	type errorLogger struct{}

	func (l *errorLogger) AmiError(err error) {
		println("Got error from Ami:", err.Error())
	}

	pr, err := ami.NewProducer(
		ami.ProducerOptions{
			ErrorNotifier:     &errorLogger{},
			Name:              "ruthie",
			PendingBufferSize: 10000000,
			PipeBufferSize:    50000,
			PipePeriod:        time.Microsecond * 1000,
			ShardsCount:       10,
		},
		&redis.ClusterOptions{
			Addrs:        []string{"172.17.0.1:7001", "172.17.0.1:7002"},
			ReadTimeout:  time.Second * 60,
			WriteTimeout: time.Second * 60,
		},
	)
	if err != nil {
		panic(err)
	}

	for i := 0; i < 10000; i++ {
		pr.Send("{}")
	}

	pr.Close()
```

## Consumer example

```
	type errorLogger struct{}

	func (l *errorLogger) AmiError(err error) {
		println("Got error from Ami:", err.Error())
	}

	cn, err := ami.NewConsumer(
		ami.ConsumerOptions{
			Consumer:          "alice",
			ErrorNotifier:     &errorLogger{},
			Name:              "ruthie",
			PendingBufferSize: 10000000,
			PipeBufferSize:    50000,
			PipePeriod:        time.Microsecond * 1000,
			PrefetchCount:     100,
			ShardsCount:       10,
		},
		&redis.ClusterOptions{
			Addrs:        []string{"172.17.0.1:7001", "172.17.0.1:7002"},
			ReadTimeout:  time.Second * 60,
			WriteTimeout: time.Second * 60,
		},
	)
	if err != nil {
		panic(err)
	}

	c := cn.Start()

	wg := sync.WaitGroup{}
	wg.Add(1)

	go func() {
		for {
			m, more := <-c
			if !more {
				break
			}
			println("Got", m.Body, "ID", m.ID)
			cn.Ack(m)
		}
		wg.Done()
	}()

	time.Sleep(time.Second)

	cn.Stop()
	wg.Wait()

	cn.Close()
```


amqp

A real time messaging server to build a scalable in-app notifications, multiplayer games, chat apps in web and mobile apps.

<p align="center">
    <img src="https://raw.githubusercontent.com/Clivern/Beaver/main/assets/img/gopher.png" width="200" />
    <h3 align="center">Beaver</h3>
    <p align="center">A Real Time Messaging Server.</p>
    <p align="center">
        <a href="https://github.com/Clivern/Beaver/actions/workflows/build.yml">
            <img src="https://github.com/Clivern/Beaver/actions/workflows/build.yml/badge.svg">
        </a>
        <a href="https://github.com/Clivern/Beaver/actions">
            <img src="https://github.com/Clivern/Beaver/workflows/Release/badge.svg">
        </a>
        <a href="https://github.com/Clivern/Beaver/releases">
            <img src="https://img.shields.io/badge/Version-1.5.0-red.svg">
        </a>
        <a href="https://goreportcard.com/report/github.com/Clivern/Beaver">
            <img src="https://goreportcard.com/badge/github.com/Clivern/Beaver?v=1.5.0">
        </a>
        <a href="https://godoc.org/github.com/clivern/beaver">
            <img src="https://godoc.org/github.com/clivern/beaver?status.svg">
        </a>
        <a href="https://github.com/Clivern/Beaver/blob/master/LICENSE">
            <img src="https://img.shields.io/badge/LICENSE-MIT-orange.svg">
        </a>
    </p>
</p>
<br/>
<p align="center">
    <img src="https://raw.githubusercontent.com/Clivern/Beaver/main/assets/charts/chart.png?v=1.5.0" width="60%" />
</p>

Beaver is a real-time messaging server. With beaver you can easily build scalable in-app notifications, realtime graphs, multiplayer games, chat applications, geotracking and more in web applications and mobile apps.


## Documentation

#### Run Beaver on Ubuntu

Download [the latest beaver binary](https://github.com/Clivern/Beaver/releases). Make it executable from everywhere.

```zsh
$ export BEAVER_LATEST_VERSION=$(curl --silent "https://api.github.com/repos/Clivern/Beaver/releases/latest" | jq '.tag_name' | sed -E 's/.*"([^"]+)".*/\1/' | tr -d v)

$ curl -sL https://github.com/Clivern/Beaver/releases/download/v{$BEAVER_LATEST_VERSION}/beaver_{$BEAVER_LATEST_VERSION}_Linux_x86_64.tar.gz | tar xz
```

Then install `redis` cluster or a single node. Update the following config file with redis configs.


Create the configs file `config.yml` from `config.dist.yml`. Something like the following:

```yaml
# App configs
app:
    # Env mode (dev or prod)
    mode: ${BEAVER_APP_MODE:-prod}
    # HTTP port
    port: ${BEAVER_API_PORT:-8080}
    # Hostname
    hostname: ${BEAVER_API_HOSTNAME:-127.0.0.1}
    # TLS configs
    tls:
        status: ${BEAVER_API_TLS_STATUS:-off}
        pemPath: ${BEAVER_API_TLS_PEMPATH:-cert/server.pem}
        keyPath: ${BEAVER_API_TLS_KEYPATH:-cert/server.key}

    # API Configs
    api:
        key: ${BEAVER_API_KEY:-6c68b836-6f8e-465e-b59f-89c1db53afca}

    # Beaver Secret
    secret: ${BEAVER_SECRET:-sWUhHRcs4Aqa0MEnYwbuQln3EW8CZ0oD}

    # Runtime, Requests/Response and Beaver Metrics
    metrics:
        prometheus:
            # Route for the metrics endpoint
            endpoint: ${BEAVER_METRICS_PROM_ENDPOINT:-/metrics}

    # Application Database
    database:
        # Database driver
        driver: ${BEAVER_DB_DRIVER:-redis}

        # Redis Configs
        redis:
            # Redis address
            address: ${BEAVER_DB_REDIS_ADDR:-localhost:6379}
            # Redis password
            password: ${BEAVER_DB_REDIS_PASSWORD:- }
            # Redis database
            db: ${BEAVER_DB_REDIS_DB:-0}

    # Log configs
    log:
        # Log level, it can be debug, info, warn, error, panic, fatal
        level: ${BEAVER_LOG_LEVEL:-info}
        # Output can be stdout or abs path to log file /var/logs/beaver.log
        output: ${BEAVER_LOG_OUTPUT:-stdout}
        # Format can be json
        format: ${BEAVER_LOG_FORMAT:-json}
```

The run the `beaver` with `systemd`

```zsh
$ beaver api -c /path/to/config.yml
```

### API Endpoints

Create a Config `app_name`:

```bash
$ curl -X POST \
    -H "Content-Type: application/json" \
    -H "X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca" \
    -d '{"key":"app_name","value":"Beaver"}' \
    "http://localhost:8080/api/config"
```

Get a Config `app_name`:

```bash
$ curl -X GET \
    -H "Content-Type: application/json" \
    -H "X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca" \
    "http://localhost:8080/api/config/app_name"

{"key":"app_name","value":"Beaver"}
```

Update a Config `app_name`:

```bash
$ curl -X PUT \
    -H "Content-Type: application/json" \
    -H "X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca" \
    -d '{"value":"Beaver"}' \
    "http://localhost:8080/api/config/app_name"
```

Delete a Config `app_name`:

```bash
$ curl -X DELETE \
    -H "Content-Type: application/json" \
    -H "X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca" \
    "http://localhost:8080/api/config/app_name"
```

Create a Channel:

```bash
# Private Channel
$ curl -X POST \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"name": "app_x_chatroom_1", "type": "private"}' \
    'http://localhost:8080/api/channel'

# Public Channel
$ curl -X POST \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"name": "app_y_chatroom_1", "type": "public"}' \
    'http://localhost:8080/api/channel'

# Presence Channel
$ curl -X POST \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"name": "app_z_chatroom_5", "type": "presence"}' \
    'http://localhost:8080/api/channel'
```

Get a Channel:

```bash
$ curl -X GET \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '' \
    'http://localhost:8080/api/channel/app_x_chatroom_1'
{
    "created_at":1545573214,
    "listeners_count":0,
    "name":"app_x_chatroom_1",
    "subscribers_count":0,
    "type":"private",
    "updated_at":1545573214
}

$ curl -X GET \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '' \
    'http://localhost:8080/api/channel/app_y_chatroom_1'
{
    "created_at":1545573219,
    "listeners_count":0,
    "name":"app_y_chatroom_1",
    "subscribers_count":0,
    "type":"public",
    "updated_at":1545573219
}

$ curl -X GET \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '' \
    'http://localhost:8080/api/channel/app_z_chatroom_5'
{
    "created_at": 1545573225,
    "listeners": null,
    "listeners_count": 0,
    "name": "app_z_chatroom_5",
    "subscribers": null,
    "subscribers_count": 0,
    "type": "presence",
    "updated_at": 1545573225
}
```

Update a Channel `app_y_chatroom_1`:

```bash
$ curl -X PUT \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"type": "private"}' \
    'http://localhost:8080/api/channel/app_y_chatroom_1'
```

Delete a Channel `app_y_chatroom_1`:

```bash
$ curl -X DELETE \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '' \
    'http://localhost:8080/api/channel/app_y_chatroom_1'
```

Create a Client and add to `app_x_chatroom_1` Channel:

```bash
$ curl -X POST \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"channels": ["app_x_chatroom_1"]}' \
    'http://localhost:8080/api/client'
{
    "channels": [
        "app_x_chatroom_1"
    ],
    "created_at": 1545575142,
    "id": "69775af3-5f68-4725-8162-09cab63e8427",
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjoiNjk3NzVhZjMtNWY2OC00NzI1LTgxNjItMDljYWI2M2U4NDI3QDE1NDU1NzUxNDIiLCJ0aW1lc3RhbXAiOjE1NDU1NzUxNDJ9.EqL-nWwu5p7hJXWrKdZN3Ds2cxWVjNYmeP1mbl562nU",
    "updated_at": 1545575142
}
```

Get a Client `69775af3-5f68-4725-8162-09cab63e8427`:

```bash
$ curl -X GET \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '' \
    'http://localhost:8080/api/client/69775af3-5f68-4725-8162-09cab63e8427'
{
    "channels": [
        "app_x_chatroom_1"
    ],
    "created_at": 1545575142,
    "id": "69775af3-5f68-4725-8162-09cab63e8427",
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjoiNjk3NzVhZjMtNWY2OC00NzI1LTgxNjItMDljYWI2M2U4NDI3QDE1NDU1NzUxNDIiLCJ0aW1lc3RhbXAiOjE1NDU1NzUxNDJ9.EqL-nWwu5p7hJXWrKdZN3Ds2cxWVjNYmeP1mbl562nU",
    "updated_at": 1545575142
}
```

Subscribe a Client `69775af3-5f68-4725-8162-09cab63e8427` to a Channel `app_z_chatroom_5`:

```bash
$ curl -X PUT \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"channels": ["app_z_chatroom_5"]}' \
    'http://localhost:8080/api/client/69775af3-5f68-4725-8162-09cab63e8427/subscribe'
```

Unsubscribe a Client `69775af3-5f68-4725-8162-09cab63e8427` from a Channel `app_z_chatroom_5`:

```bash
$ curl -X PUT \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"channels": ["app_z_chatroom_5"]}' \
    'http://localhost:8080/api/client/69775af3-5f68-4725-8162-09cab63e8427/unsubscribe'
```

Delete a Client:

```bash
$ curl -X DELETE \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '' \
    'http://localhost:8080/api/client/69775af3-5f68-4725-8162-09cab63e8427'
```

Publish to a Channel `app_x_chatroom_1`:

```bash
$ curl -X POST \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"channel": "app_x_chatroom_1", "data": "{\"message\": \"Hello World\"}"}' \
    'http://localhost:8080/api/publish'
```

Broadcast to Channels `["app_x_chatroom_1"]`:

```bash
$ curl -X POST \
    -H 'Content-Type: application/json' \
    -H 'X-API-Key: 6c68b836-6f8e-465e-b59f-89c1db53afca' \
    -d '{"channels": ["app_x_chatroom_1"], "data": "{\"message\": \"Hello World\"}"}' \
    'http://localhost:8080/api/broadcast'
```

Sample Frontend Client

```js
function Socket(url){
    ws = new WebSocket(url);
    ws.onmessage = function(e) { console.log(e); };
    ws.onclose = function(){
        // Try to reconnect in 5 seconds
        setTimeout(function(){Socket(url)}, 5000);
    };
}

Socket("ws://localhost:8080/ws/$ID/$TOKEN");
```


## Client:

- [Go Client](https://github.com/domgolonka/beavergo) Thanks [@domgolonka](https://github.com/domgolonka)


## Versioning

For transparency into our release cycle and in striving to maintain backward compatibility, Beaver is maintained under the [Semantic Versioning guidelines](https://semver.org/) and release process is predictable and business-friendly.

See the [Releases section of our GitHub project](https://github.com/clivern/beaver/releases) for changelogs for each release version of Beaver. It contains summaries of the most noteworthy changes made in each release.


## Bug tracker

If you have any suggestions, bug reports, or annoyances please report them to our issue tracker at https://github.com/clivern/beaver/issues


## Security Issues

If you discover a security vulnerability within Beaver, please send an email to [hello@clivern.com](mailto:hello@clivern.com)


## Contributing

We are an open source, community-driven project so please feel free to join us. see the [contributing guidelines](CONTRIBUTING.md) for more details.


## License

© 2018, Clivern. Released under [MIT License](https://opensource.org/licenses/mit-license.php).

**Beaver** is authored and maintained by [@Clivern](http://github.com/clivern).


Beaver

Minimalist message bus implementation for internal communication.

# 🔊 Bus

[![GoDoc](https://godoc.org/github.com/mustafaturan/bus?status.svg)](https://godoc.org/github.com/mustafaturan/bus)
[![Build Status](https://travis-ci.org/mustafaturan/bus.svg?branch=main)](https://travis-ci.org/mustafaturan/bus)
[![Coverage Status](https://coveralls.io/repos/github/mustafaturan/bus/badge.svg?branch=main)](https://coveralls.io/github/mustafaturan/bus?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/mustafaturan/bus)](https://goreportcard.com/report/github.com/mustafaturan/bus)
[![GitHub license](https://img.shields.io/github/license/mustafaturan/bus.svg)](https://github.com/mustafaturan/bus/blob/main/LICENSE)

Bus is a minimalist event/message bus implementation for internal communication.
It is heavily inspired from my [event_bus](https://github.com/otobus/event_bus)
package for Elixir language.

## API

The method names and arities/args are stable now. No change should be expected
on the package for the version `3.x.x` except any bug fixes.

## Installation

Via go packages:
```go get github.com/mustafaturan/bus/v3```

## Usage

### Configure

The package requires a unique id generator to assign ids to events. You can
write your own function to generate unique ids or use a package that provides
unique id generation functionality.

The `bus` package respect to software design choice of the packages/projects. It
supports both singleton and dependency injection to init a `bus` instance.

*Hint:*
Check the [demo project](https://github.com/mustafaturan/bus-sample-project) for
the singleton configuration.

Here is a sample initilization using `monoton` id generator:

```go
import (
    "github.com/mustafaturan/bus/v3"
    "github.com/mustafaturan/monoton/v2"
    "github.com/mustafaturan/monoton/v2/sequencer"
)

func NewBus() *bus.Bus {
    // configure id generator (it doesn't have to be monoton)
    node        := uint64(1)
    initialTime := uint64(1577865600000) // set 2020-01-01 PST as initial time
    m, err := monoton.New(sequencer.NewMillisecond(), node, initialTime)
    if err != nil {
        panic(err)
    }

    // init an id generator
    var idGenerator bus.Next = m.Next

    // create a new bus instance
    b, err := bus.NewBus(idGenerator)
    if err != nil {
        panic(err)
    }

    // maybe register topics in here
    b.RegisterTopics("order.received", "order.fulfilled")

    return b
}
```

### Register Event Topics

To emit events to the topics, topic names need to be registered first:

```go
// register topics
b.RegisterTopics("order.received", "order.fulfilled")
```

### Register Event Handlers

To receive topic events you need to register handlers; A handler basically
requires two vals which are a `Handle` function and topic `Matcher` regex
pattern.

```go
handler := bus.Handler{
    Handle: func(ctx context.Context, e bus.Event) {
        // do something
        // NOTE: Highly recommended to process the event in an async way
    },
    Matcher: ".*", // matches all topics
}
b.RegisterHandler("a unique key for the handler", handler)
```

### Emit Events

```go
// if txID val is blank, bus package generates one using the id generator
ctx := context.Background()
ctx = context.WithValue(ctx, bus.CtxKeyTxID, "some-transaction-id-if-exists")
// with optional source
ctx = context.WithValue(ctx, bus.CtxKeySource, "source-of-the-event")

// event topic name (must be registered before)
topic := "order.received"

// interface{} data for event
order := make(map[string]string)
order["orderID"]     = "123456"
order["orderAmount"] = "112.20"
order["currency"]    = "USD"

// emit the event
err := b.Emit(ctx, topic, order)

if err != nil {
    // report the err
    fmt.Println(err)
}

// emit the event with options
err := b.EmitWithOpts(ctx, topic, order, bus.WithTxID("some-tx-id"))

if err != nil {
    // report the err
    fmt.Println(err)
}
```

### Processing Events

When an event is emitted, the topic handlers receive the event synchronously.
It is highly recommended to process events asynchronous. Package leave the
decision to the packages/projects to use concurrency abstractions depending on
use-cases. Each handlers receive the same event as ref of `bus.Event` struct:

```go
// Event data structure
type Event struct {
    ID         string      // identifier
    TxID       string      // transaction identifier
    Topic      string      // topic name
    Source     string      // source of the event
    OccurredAt time.Time   // creation time in nanoseconds
    Data       interface{} // actual event data
}
```

### Sample Project

A [demo project](https://github.com/mustafaturan/bus-sample-project) with three
consumers which increments a `counter` for each event topic, `printer` consumer
which prints all events and lastly `calculator` consumer which sums amounts.

### Benchmarks

Command:
```
go test -benchtime 10000000x -benchmem -run=^$ -bench=. github.com/mustafaturan/bus/v3
```

Results:
```
goos: darwin
goarch: amd64
pkg: github.com/mustafaturan/bus/v3
cpu: Intel(R) Core(TM) i5-6267U CPU @ 2.90GHz
BenchmarkEmit-4                      	10000000	       180.5 ns/op	       8 B/op	       0 allocs/op
BenchmarkEmitWithoutTxID-4           	10000000	       244.6 ns/op	      72 B/op	       2 allocs/op
BenchmarkEmitWithOpts-4              	10000000	       280.8 ns/op	     112 B/op	       4 allocs/op
BenchmarkEmitWithOptsUnspecified-4   	10000000	       169.4 ns/op	       8 B/op	       0 allocs/op
PASS
ok  	github.com/mustafaturan/bus/v3	8.884s
```

## Contributing

All contributors should follow [Contributing Guidelines](CONTRIBUTING.md) before creating pull requests.

## Credits

[Mustafa Turan](https://github.com/mustafaturan)

## License

Apache License 2.0

Copyright (c) 2021 Mustafa Turan

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


Real-time messaging (Websockets or SockJS) server in Go.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, SSE/EventSource, GRPC, WebTransport). Centrifugo has the concept of channel subscriptions – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

## Documentation

* [Centrifugo official documentation site](https://centrifugal.dev)
* [Installation instructions](https://centrifugal.dev/docs/getting-started/installation)
* [Getting started tutorial](https://centrifugal.dev/docs/getting-started/quickstart)
* [Design overview and idiomatic usage](https://centrifugal.dev/docs/getting-started/design)
* [Build a WebSocket chat/messenger app with Centrifugo](https://centrifugal.dev/docs/tutorial/intro) tutorial
* [Centrifugal blog](https://centrifugal.dev/blog)
* [FAQ](https://centrifugal.dev/docs/faq)

## Join community

* [Telegram](https://t.me/joinchat/ABFVWBE0AhkyyhREoaboXQ)
* [Discord](https://discord.gg/tYgADKx)
* [Twitter](https://twitter.com/centrifugalabs)

## Why Centrifugo

The core idea of Centrifugo is simple – it's a PUB/SUB server on top of modern real-time transports:

<img src="https://centrifugal.dev/img/protocol_pub_sub.png?v=2" />

The hard part is to make this concept production-ready, efficient, flexible and available from different application environments. Centrifugo is a mature solution that already helped many projects with adding real-time features and scale towards many concurrent connections. Centrifugo provides a set of features not available in other open-source solutions in the area:

* Efficient real-time transports: WebSocket, HTTP-streaming, Server-Sent Events (SSE), GRPC, WebTransport
* Built-in scalability with Redis (or Redis Cluster, or Redis-compatible storage – ex. AWS Elasticache, KeyDB, DragonflyDB, etc), or Nats.
* Simple HTTP and GRPC server API to communicate with Centrifugo from the app backend
* Flexible connection authentication mechanisms: JWT and proxy-like
* Channel subscription multiplexing over a single connection
* Different types of subscriptions: client-side and server-side
* Various channel permission strategies, channel namespace concept
* Hot message history in channels, with automatic message recovery upon reconnect, cache recovery mode (deliver latest publication immediately upon subscription)
* Delta compression in channels based on Fossil algorithm
* Online channel presence information, with join/leave notifications
* A way to send RPC calls to the backend over the real-time connection
* Strict and effective client protocol wrapped by several official SDKs
* JSON and binary Protobuf message transfer, with optimized serialization
* Beautiful embedded admin web UI
* And much more, visit [Centrifugo documentation site](https://centrifugal.dev)

## Backing

This repository is hosted by [packagecloud.io](https://packagecloud.io/).

<a href="https://packagecloud.io/"><img height="46" width="158" alt="Private NPM registry and Maven, RPM, DEB, PyPi and RubyGem Repository · packagecloud" src="https://packagecloud.io/images/packagecloud-badge.png" /></a>

Also thanks to [JetBrains](https://www.jetbrains.com/) for supporting OSS (most of the code here written in Goland):

<a href="https://www.jetbrains.com/"><img height="140" src="https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.png" alt="JetBrains logo"></a>


Centrifugo

A push notification server send message to your iOS devices.

Chanify

A high-level event driven consumer/producer supporting various "dialects" such as Apache Kafka.

Commander

Sending [Line](https://at.line.me/en) notifications using a binary, docker or Drone CI.

# drone-line

![drone-line](./images/line.png)

[![GoDoc](https://godoc.org/github.com/appleboy/drone-line?status.svg)](https://godoc.org/github.com/appleboy/drone-line)
[![Build Status](https://cloud.drone.io/api/badges/appleboy/drone-line/status.svg)](https://cloud.drone.io/appleboy/drone-line)
[![codecov](https://codecov.io/gh/appleboy/drone-line/branch/master/graph/badge.svg)](https://codecov.io/gh/appleboy/drone-line)
[![Go Report Card](https://goreportcard.com/badge/github.com/appleboy/drone-line)](https://goreportcard.com/report/github.com/appleboy/drone-line)
[![Docker Pulls](https://img.shields.io/docker/pulls/appleboy/drone-line.svg)](https://hub.docker.com/r/appleboy/drone-line/)
[![microbadger](https://images.microbadger.com/badges/image/appleboy/drone-line.svg)](https://microbadger.com/images/appleboy/drone-line "Get your own image badge on microbadger.com")
[![Release](https://github-release-version.herokuapp.com/github/appleboy/drone-line/release.svg?style=flat)](https://github.com/appleboy/drone-line/releases/latest)
[![Build status](https://ci.appveyor.com/api/projects/status/pmkfbnwtlf1fm45l/branch/master?svg=true)](https://ci.appveyor.com/project/appleboy/drone-line/branch/master)

Sending line notifications using a binary, docker or [Drone CI](https://docs.drone.io/).

## Register Line BOT API Trial

Please refer to [LINE Business Center](https://at.line.me/en/).

## Feature

* [x] Send multiple Message.
* [x] Send Text Message.
* [x] Send Video Message.
* [x] Send Audio Message.
* [x] Send Sticker Message.
* [x] Send Location Message.
* [x] Support [prometheus](https://prometheus.io) metrics API.
* [x] Automatically install TLS certificates from [Let's Encrypt](https://letsencrypt.org/).
* [x] Support [Localtunnel](https://localtunnel.github.io/www/) for webhook tunnel.
* [x] Support [Line Notify](https://notify-bot.line.me/en/).

> Localtunnel allows you to easily share a web service on your local development machine without messing with DNS and firewall settings.

Memory Usage:

![Memory Usage](./screenshots/memory_usage.png)

Notification Count Usage:

![Notification Count Usage](./screenshots/notification.png)

## Build or Download a binary

The pre-compiled binaries can be downloaded from [release page](https://github.com/appleboy/drone-line/releases). Support the following OS type.

* Windows amd64/386
* Linux amd64/386
* Darwin amd64/386

With `Go` installed

```sh
go get -u -v github.com/appleboy/drone-line
```

or build the binary with the following command:

```sh
make build
```

## Docker

Build the docker image with the following commands:

```sh
make docker
```

## Usage

There are three ways to send notification.

* [usage from binary](#usage-from-binary)
* [usage from docker](#usage-from-docker)
* [usage from drone ci](#usage-from-drone-ci)

## Usage from binary

### Setup Webhook service

Setup Webhook service as default port `8088`.

```bash
drone-line \
  --secret xxxx \
  --token xxxx \
  webhook
```

Change default webhook port to `8089`.

```bash
drone-line \
  --port 8089 \
  --secret xxxx \
  --token xxxx \
  webhook
```

Use [localtunnel](https://localtunnel.github.io/www/) to tunnel your locally running bot so that Line can reach the webhook.

```bash
drone-line \
  -s secret \
  -t token \
  --tunnel \
  --port 2002 \
  webhook
```

Use [Let's Encrypt](https://letsencrypt.org/). Please make sure you have permission to listen on `443` port.

```bash
drone-line \
  -s secret \
  -t token \
  -autotls \
  -host example.com \
  -cache /var/www/.cache \
  --port 443 \
  webhook
```

**Tips:** Another way to use [ngrok](https://ngrok.com/) to tunnel your locally running bot so that Line can reach the webhook.

#### Send Notification

Setup the `--to` flag after fetch user id from webhook service.

```bash
drone-line \
  --secret xxxx \
  --token xxxx \
  --to xxxx \
  --message "Test Message"
```

#### Send LINE Notify

If you connect your service with LINE Notify, LINE users can easily receive notifications from it.
See the [documentation](https://notify-bot.line.me/en/).

```sh
drone-line \
  --token xxxx \
  --message "Test Message" \
  notify
```

## Usage from docker

Setup Webhook service as default port `8088`.

```bash
docker run --rm \
  -e LINE_CHANNEL_SECRET=xxxxxxx \
  -e LINE_CHANNEL_TOKEN=xxxxxxx \
  appleboy/drone-line webhook
```

Change default webhook port to `8089`.

```bash
docker run --rm \
  -e LINE_CHANNEL_SECRET=xxxxxxx \
  -e LINE_CHANNEL_TOKEN=xxxxxxx \
  -e LINE_PORT=8089 \
  appleboy/drone-line webhook
```

**Tips:** Use [ngrok](https://ngrok.com/) to tunnel your locally running bot so that Line can reach the webhook.

Send Notification

```bash
docker run --rm \
  -e LINE_CHANNEL_SECRET=xxxxxxx \
  -e LINE_CHANNEL_TOKEN=xxxxxxx \
  -e LINE_TO=xxxxxxx \
  -e LINE_MESSAGE=test \
  -e LINE_IMAGES=https://example.com/1.png \
  -e LINE_VIDEOS=https://example.com/1.mp4 \
  -e LINE_AUDIOS=https://example.com/1.mp3::1000 \
  -e LINE_STICKERS=1::1 \
  -e LINE_LOCATIONS=title::address::latitude::longitude \
  -e LINE_DELIMITER=:: \
  appleboy/drone-line
```

## Usage from drone ci

Execute from the working directory:

```bash
docker run --rm \
  -e PLUGIN_CHANNEL_SECRET=xxxxxxx \
  -e PLUGIN_CHANNEL_TOKEN=xxxxxxx \
  -e PLUGIN_TO=xxxxxxx \
  -e PLUGIN_MESSAGE=test \
  -e PLUGIN_IMAGES=https://example.com/1.png \
  -e PLUGIN_VIDEOS=https://example.com/1.mp4 \
  -e PLUGIN_AUDIOS=https://example.com/1.mp3::1000 \
  -e PLUGIN_STICKERS=1::1 \
  -e PLUGIN_LOCATIONS=title::address::latitude::longitude \
  -e PLUGIN_DELIMITER=:: \
  -e PLUGIN_ONLY_MATCH_EMAIL=false \
  -e DRONE_REPO_OWNER=appleboy \
  -e DRONE_REPO_NAME=go-hello \
  -e DRONE_COMMIT_SHA=e5e82b5eb3737205c25955dcc3dcacc839b7be52 \
  -e DRONE_COMMIT_BRANCH=master \
  -e DRONE_COMMIT_AUTHOR=appleboy \
  -e DRONE_COMMIT_AUTHOR_EMAIL=appleboy@gmail.com \
  -e DRONE_COMMIT_MESSAGE=Test_Your_Commit \
  -e DRONE_BUILD_NUMBER=1 \
  -e DRONE_BUILD_STATUS=success \
  -e DRONE_BUILD_LINK=http://github.com/appleboy/go-hello \
  -e DRONE_JOB_STARTED=1477550550 \
  -e DRONE_JOB_FINISHED=1477550750 \
  -v $(pwd):$(pwd) \
  -w $(pwd) \
  appleboy/drone-line
```

You can get more [information](DOCS.md) about how to use scp plugin in drone.

## Testing

Test the package with the following command:

```sh
make test
```


drone-line

Emits events using Go way, with wildcard, predicates, cancellation possibilities and many other good wins.

# Emitter [![wercker status](https://app.wercker.com/status/e5a44746dc89b513ed28e8a18c5c05c2/s "wercker status")](https://app.wercker.com/project/bykey/e5a44746dc89b513ed28e8a18c5c05c2) [![Coverage Status](https://coveralls.io/repos/olebedev/emitter/badge.svg?branch=HEAD&service=github)](https://coveralls.io/github/olebedev/emitter?branch=HEAD) [![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/olebedev/emitter)

The emitter package implements a channel-based pubsub pattern. The design goals are to use Golang concurrency model instead of flat callbacks and to design a very simple API that is easy to consume.
## Why?
Go has expressive concurrency model but nobody uses it properly for pubsub as far as I can tell (in the year 2015). I implemented my own solution as I could not find any other that meets my expectations. Please, read [this article](#) for more information.


## What it does?

- [sync/async event emitting](#flags)
- [predicates/middlewares](#middlewares)
- [bi-directional wildcard](#wildcard)
- [discard emitting if needed](#cancellation)
- [merge events from different channels](#groups)
- [shallow on demand type casting](#event)
- [work with callbacks(traditional way)](#callbacks-only-usage)


## Brief example

```go
e := &emitter.Emitter{}
go func(){
	<-e.Emit("change", 42) // wait for the event sent successfully
	<-e.Emit("change", 37)
	e.Off("*") // unsubscribe any listeners
}()

for event := range e.On("change") {
	// do something with event.Args
	println(event.Int(0)) // cast the first argument to int
}
// listener channel was closed
```

## Constructor
`emitter.New` takes a `uint` as the first argument to indicate what buffer size should be used for listeners. It is also possible to change the buffer capacity during runtime using the following code: `e.Cap = 10`.

By default, the emitter uses one goroutine per listener to send an event. You can change that behavior from asynchronous to synchronous by passing `emitter.Sync` flag as shown here: `e.Use("*", emitter.Sync)`. I recommend specifying middlewares(see [below](#middlewares)) for the emitter at the begining.

## Wildcard
The package allows publications and subscriptions with wildcard. This feature is based on `path.Match` function.

Example:

```go
go e.Emit("something:special", 42)
event := <-e.Once("*") // search any events
println(event.Int(0)) // will print 42

// or emit an event with wildcard path
go e.Emit("*", 37) // emmit for everyone
event := <-e.Once("something:special")
println(event.Int(0)) // will print 37
```

Note that the wildcard uses `path.Match`, but the lib does not return errors related to parsing for this is not the main feature. Please check the topic specifically via `emitter.Test()` function.

## Middlewares
An important part of pubsub package is the predicates. It should be allowed to skip some events. Middlewares address this problem.
The middleware is a function that takes a pointer to the `Event` as its first argument. A middleware is capable of doing the following items:

1. It allows you to modify an event.
2. It allows skipping the event emitting if needed.
3. It also allows modification of the event's arguments.
4. It allows you to specify the mode to describe how exactly an event should be emitted(see [below](#flags)).

There are two ways to add middleware into the event emitting flow:

- via .On("event", middlewares...)
- via .Use("event", middlewares...)

The first one add middlewares only for a particular listener, while the second one adds middlewares for all events with a given topic.

For example:
```go
// use synchronous mode for all events, it also depends
// on the emitter capacity(buffered/unbuffered channels)
e.Use("*", emitter.Sync)
go e.Emit("something:special", 42)

// define predicate
event := <-e.Once("*", func(ev *emitter.Event){
	if ev.Int(0) == 42 {
	    // skip sending
		ev.Flags = ev.Flags | emitter.FlagVoid
	}
})
panic("will never happen")
```


## Flags
Flags needs to describe how exactly the event should be emitted. The available options are listed [here](https://godoc.org/github.com/olebedev/emitter#Flag).

Every event(`emitter.Event`) has a field called`.Flags` that contains flags as a binary mask.
Flags can be set only via middlewares(see above).

There are several predefined middlewares to set needed flags:

- [`emitter.Once`](https://godoc.org/github.com/olebedev/emitter#Once)
- [`emitter.Close`](https://godoc.org/github.com/olebedev/emitter#Close)
- [`emitter.Void`](https://godoc.org/github.com/olebedev/emitter#Void)
- [`emitter.Skip`](https://godoc.org/github.com/olebedev/emitter#Skip)
- [`emitter.Sync`](https://godoc.org/github.com/olebedev/emitter#Sync)
- [`emitter.Reset`](https://godoc.org/github.com/olebedev/emitter#Reset)

You can chain the above flags as shown below:
```go
e.Use("*", emitter.Void) // skip sending for any events
go e.Emit("surprise", 65536)
event := <-e.On("*", emitter.Reset, emitter.Sync, emitter.Once) // set custom flags for this listener
pintln(event.Int(0)) // prints 65536
```

## Cancellation
Golang provides developers with a powerful control for its concurrency flow. We know the state of a channel and whether it would block a go routine or not. So, by using this language construct, we can discard any emitted event. It's a good practice to design your application with timeouts so that you cancel the operations if needed as shown below:

Assume you have time out to emit the events:
```go
done := e.Emit("broadcast", "the", "event", "with", "timeout")

select {
case <-done:
	// so the sending is done
case <-time.After(timeout):
	// time is out, let's discard emitting
	close(done)
}
```

It's pretty useful to control any goroutines inside an emitter instance.

## Callbacks-only usage
using the emitter in more traditional way is possible, as well. If you don't need the async mode or you very attentive to the application resources, then the recipe is to use an emitter with zero capacity or to use `FlagVoid` to skip sending into the listener channel and use middleware as callback:

```go
e := &emitter.Emitter{}
e.Use("*", emitter.Void)

go e.Emit("change", "field", "value")
e.On("change", func(event *Event){
	// handle changes here
	field := event.String(0)
	value := event.String(1)
	// ...and so on
})
```

## Groups
Group merges different listeners into one channel.
Example:
```go
e1 := &emitter.Emitter{}
e2 := &emitter.Emitter{}
e3 := &emitter.Emitter{}

g := &emitter.Group{Cap: 1}
g.Add(e1.On("first"), e2.On("second"), e3.On("third"))

for event := g.On() {
	// handle the event
	// event has field OriginalTopic and Topic
}
```
Also you can combine several groups into one.

See the api [here](https://godoc.org/github.com/olebedev/emitter#Group).


## Event
Event is a struct that contains event [information](https://godoc.org/github.com/olebedev/emitter#Event). Also, th event has some helpers to cast various arguments into `bool`, `string`, `float64`, `int` by given argument index with an optional default value.

Example:
```go

go e.Emit("*", "some string", 42, 37.0, true)
event := <-e.Once("*")

first := event.String(0)
second := event.Int(1)
third := event.Float(2)
fourth := event.Bool(3)

// use default value if not exists
dontExists := event.Int(10, 64)
// or use dafault value if type don't match
def := event.Int(0, 128)

// .. and so on
```

## License
MIT


emitter

event

Robust Go and Javascript Socket Library (Alternative to Socket.io).

# Glue - Robust Go and Javascript Socket Library

[![GoDoc](https://godoc.org/github.com/desertbit/glue?status.svg)](https://godoc.org/github.com/desertbit/glue)
[![Go Report Card](https://goreportcard.com/badge/github.com/desertbit/glue)](https://goreportcard.com/report/github.com/desertbit/glue)
[![Join the chat at https://gitter.im/desertbit/glue](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/desertbit/glue?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Glue is a real-time bidirectional socket library. It is a **clean**, **robust** and **efficient** alternative to [socket.io](http://socket.io/). This library is designed to connect webbrowsers with a go-backend in a simple way. It automatically detects supported socket layers and chooses the most suitable one. This library handles automatic reconnections on disconnections and handles caching to bridge those disconnections. The server implementation is **thread-safe** and **stable**. The API is **fixed** and there won't be any breaking API changes.

## Socket layers
Currently two socket layers are supported:
- **WebSockets** - This is the primary option. They are used if the webbrowser supports WebSockets defined by [RFC 6455](https://tools.ietf.org/html/rfc6455).
- **AjaxSockets** - This socket layer is used as a fallback mode.

## Support
Feel free to contribute to this project. Please check the [TODO](TODO.md) file for more information.

## Install
### Client
The client javascript Glue library is located in **[client/dist/glue.js](client/dist/glue.js)**.

You can use bower to install the client library:

`bower install --save glue-socket`

### Server
Get the source and start hacking.

`go get github.com/desertbit/glue`

Import it with:

```go
import "github.com/desertbit/glue"
```

## Documentation
### Client - Javascript Library
A simple call to glue() without any options will establish a socket connection to the same host. A glue socket object is returned.

```js
// Create and connect to the server.
// Optional pass a host string and options.
var socket = glue();
```

Optional Javascript options which can be passed to Glue:

```js
var host = "https://foo.bar";

var opts = {
    // The base URL is appended to the host string. This value has to match with the server value.
    baseURL: "/glue/",

    // Force a socket type.
    // Values: false, "WebSocket", "AjaxSocket"
    forceSocketType: false,

    // Kill the connect attempt after the timeout.
    connectTimeout:  10000,

    // If the connection is idle, ping the server to check if the connection is stil alive.
    pingInterval:           35000,
    // Reconnect if the server did not response with a pong within the timeout.
    pingReconnectTimeout:   5000,

    // Whenever to automatically reconnect if the connection was lost.
    reconnect:          true,
    reconnectDelay:     1000,
    reconnectDelayMax:  5000,
    // To disable set to 0 (endless).
    reconnectAttempts:  10,

    // Reset the send buffer after the timeout.
    resetSendBufferTimeout: 10000
};

// Create and connect to the server.
// Optional pass a host string and options.
var socket = glue(host, opts);
```

The glue socket object has following public methods:

```js
// version returns the glue socket protocol version.
socket.version();

// type returns the current used socket type as string.
// Either "WebSocket" or "AjaxSocket".
socket.type();

// state returns the current socket state as string.
// Following states are available:
//  - "disconnected"
//  - "connecting"
//  - "reconnecting"
//  - "connected"
socket.state();

// socketID returns the socket's ID.
// This is a cryptographically secure pseudorandom number.
socket.socketID();

// send a data string to the server.
// One optional discard callback can be passed.
// It is called if the data could not be send to the server.
// The data is passed as first argument to the discard callback.
// returns:
//  1 if immediately send,
//  0 if added to the send queue and
//  -1 if discarded.
socket.send(data, discardCallback);

// onMessage sets the function which is triggered as soon as a message is received.
socket.onMessage(f);

// on binds event functions to events.
// This function is equivalent to jQuery's on method syntax.
// Following events are available:
//  - "connected"
//  - "connecting"
//  - "disconnected"
//  - "reconnecting"
//  - "error"
//  - "connect_timeout"
//  - "timeout"
//  - "discard_send_buffer"
socket.on();

// Reconnect to the server.
// This is ignored if the socket is not disconnected.
// It will reconnect automatically if required.
socket.reconnect();

// close the socket connection.
socket.close();

// channel returns the given channel object specified by name
// to communicate in a separate channel than the default one.
socket.channel(name);
```

A channel object has following public methods:

```js
// onMessage sets the function which is triggered as soon as a message is received.
c.onMessage(f);

// send a data string to the channel.
// One optional discard callback can be passed.
// It is called if the data could not be send to the server.
// The data is passed as first argument to the discard callback.
// returns:
//  1 if immediately send,
//  0 if added to the send queue and
//  -1 if discarded.
c.send(data, discardCallback);
```

### Server - Go Library
Check the Documentation at [GoDoc.org](https://godoc.org/github.com/desertbit/glue).

#### Use a custom HTTP multiplexer
If you choose to use a custom HTTP multiplexer, then it is possible to deactivate the automatic HTTP handler registration of glue.

```go
// Create a new glue server without configuring and starting the HTTP server.
server := glue.NewServer(glue.Options{
    HTTPSocketType: HTTPSocketTypeNone,
})

//...
```

The glue server implements the ServeHTTP method of the HTTP Handler interface of the http package. Use this to register the glue HTTP handler with a custom multiplexer. Be aware, that the URL of the custom HTTP handler has to match with the glue HTTPHandleURL options string.

#### Reading data
Data has to be read from the socket and each channel. If you don't require to read data from the socket or a channel, then discard received data with the DiscardRead() method. If received data is not discarded, then the read buffer will block as soon as it is full, which will also block the keep-alive mechanism of the socket. The result would be a closed socket...

```go
// ...

// Discard received data from the main socket channel.
// Hint: Channels have to be discarded separately.
s.DiscardRead()

// ...

// Create a channel.
c := s.Channel("golang")

// Discard received data from a channel.
c.DiscardRead()
```

#### Bind custom values to a socket
The socket.Value interface is a placeholder for custom data.

```go
type CustomValues struct {
    Foo string
    Bar int
}

// ...

s.Value = &CustomValues{
    Foo: "Hello World",
    Bar: 900,
}

// ...

v, ok := s.Value.(*CustomValues)
if !ok {
    // Handle error
    return
}
```

### Channels
Channels are separate communication channels from the client to the server of a single socket connections. Multiple separate communication channels can be created:

Server:

```go
// ...

// Create a channel.
c := s.Channel("golang")

// Set the channel on read event function.
c.OnRead(func(data string) {
    // ...
})

// Write to the channel.
c.Write("Hello Gophers!")
```

Client:

```js
var c = socket.channel("golang");

c.onMessage(function(data) {
    console.log(data);
});

c.send("Hello World");
```

### Broadcasting Messages

With Glue it is easy to broadcast messages to multiple clients. The Glue Server keeps track of all active connected client sessions.
You can make use of the server **Sockets**, **GetSocket** or **OnNewSocket** methods to implement broadcasting.


## Example
This socket library is very straightforward to use. Check the [sample directory](sample) for more examples.

### Client

```html
<script>
    // Create and connect to the server.
    // Optional pass a host string and options.
    var socket = glue();

    socket.onMessage(function(data) {
        console.log("onMessage: " + data);

        // Echo the message back to the server.
        socket.send("echo: " + data);
    });


    socket.on("connected", function() {
        console.log("connected");
    });

    socket.on("connecting", function() {
        console.log("connecting");
    });

    socket.on("disconnected", function() {
        console.log("disconnected");
    });

    socket.on("reconnecting", function() {
        console.log("reconnecting");
    });

    socket.on("error", function(e, msg) {
        console.log("error: " + msg);
    });

    socket.on("connect_timeout", function() {
        console.log("connect_timeout");
    });

    socket.on("timeout", function() {
        console.log("timeout");
    });

    socket.on("discard_send_buffer", function() {
        console.log("some data could not be send and was discarded.");
    });
</script>
```

### Server
Read data from the socket with a read event function. Check the sample directory for other ways of reading data from the socket.

```go
import (
    "log"
    "net/http"

    "github.com/desertbit/glue"
)

func main() {
    // Create a new glue server.
    server := glue.NewServer(glue.Options{
        HTTPListenAddress: ":8080",
    })

    // Release the glue server on defer.
    // This will block new incoming connections
    // and close all current active sockets.
    defer server.Release()

    // Set the glue event function to handle new incoming socket connections.
    server.OnNewSocket(onNewSocket)

    // Run the glue server.
    err := server.Run()
    if err != nil {
        log.Fatalf("Glue Run: %v", err)
    }
}

func onNewSocket(s *glue.Socket) {
    // Set a function which is triggered as soon as the socket is closed.
    s.OnClose(func() {
        log.Printf("socket closed with remote address: %s", s.RemoteAddr())
    })

    // Set a function which is triggered during each received message.
    s.OnRead(func(data string) {
        // Echo the received data back to the client.
        s.Write(data)
    })

    // Send a welcome string to the client.
    s.Write("Hello Client")
}
```

## Similar Go Projects
- [go-socket.io](https://github.com/googollee/go-socket.io) - socket.io library for golang, a realtime application framework.


Glue

[![Go Report Card](https://goreportcard.com/badge/github.com/stanipetrosyan/go-eventbus)](https://goreportcard.com/report/github.com/stanipetrosyan/go-eventbus)
[![codecov](https://codecov.io/gh/stanipetrosyan/go-eventbus/graph/badge.svg?token=YAGXYA64E6)](https://codecov.io/gh/stanipetrosyan/go-eventbus)
[![Go Reference](https://pkg.go.dev/badge/github.com/stanipetrosyan/go-eventbus.svg)](https://pkg.go.dev/github.com/stanipetrosyan/go-eventbus)
![workflow](https://github.com/StaniPetrosyan/go-eventbus/actions/workflows/test.yml/badge.svg)

# EventBus for Golang

## Description

This is a simple implementation of an event bus in golang. Actually support follwing pattern:

- [x] publish/subscribe
- [x] request/response

## Get Started

To start use eventbus in your project, you can run the following command.

```
go get github.com/stanipetrosyan/go-eventbus
```

And import
``` go
import (
	goeventbus "github.com/stanipetrosyan/go-eventbus"
)

```

## Publish/Subscribe

Simple example of publish/subscribe pattern.

```go

eventbus = goeventbus.NewEventBus()

address := "topic"
options := goeventbus.NewMessageOptions().AddHeader("header", "value")
message := goeventbus.CreateMessage().SetBody("Hi Topic").SetOptions(options)

eventbus.Channel(address).Subscriber().Listen(func(dc goeventbus.Context) {
	fmt.Printf("Message %s\n", dc.Result().Data)
})

eventbus.Channel(address).Publisher().Publish(message)
```

## Request/Response

Simple example of request/response pattern.

```go

eventbus = goeventbus.NewEventBus()

address := "topic"
message := goeventbus.CreateMessage().SetBody("Hi Topic")

eventbus.Channel(address).Subscriber().Listen(func(context goeventbus.Context) {
	fmt.Printf("Message %s\n", context.Result().Extract())
	context.Reply("Hello from subscriber")
})

eventbus.Channel(address).Publisher().Request(message, func(context goeventbus.Context) {
	fmt.Printf("Message %s\n", context.Result().Extract())
})
```

## Message

For publishing, you need to create a Message object using this method.

```go
message := goeventbus.CreateMessage().SetBody("Hi Topic")
```
Each message can have some options:

```go

options := goeventbus.NewMessageOptions().AddHeader("header", "value")
message := goeventbus.CreateMessage()

message.SetOptions(options)

eventBus.Channel("address").Publisher().Publish(message)
```

## Processor

A processor works like a middleware, in fact forwards messages only if the predicate is satisfied. The method accepts a function with message and return must return a boolean.

```go

eventbus.Channel("topic1").Processor(func(message goeventbus.Message) bool {
	return message.Options.Headers().Contains("header")
})
```

## Network Bus

A Network bus create a tcp connection between different services.

NetworkBus is a wrapper of local eventbus.

A simple server/client example is in `examples/networkbus` directory.


go-eventbus

A library for handling mediator patterns and simplified CQRS patterns within an event-driven architecture, inspired by csharp MediatR library.

<div align="center" style="margin-bottom:20px">
  <img src="assets/Go-MediatR.png" alt="go-mediatr" />
  <div align="center">
    <a href="https://github.com/mehdihadeli/Go-MediatR/actions/workflows/ci.yml"><img alt="build-status" src="https://github.com/mehdihadeli/Go-MediatR/actions/workflows/ci.yml/badge.svg?branch=main&style=flat-square"/></a>
    <a href="https://goreportcard.com/report/github.com/mehdihadeli/Go-MediatR" ><img alt="go report" src="https://goreportcard.com/badge/github.com/mehdihadeli/Go-MediatR"/></a>
    <a><img alt="license" src="https://img.shields.io/badge/go%20version-%3E=1.18-61CFDD.svg?style=flat-square"/></a>
    <a href="https://github.com/mehdihadeli/Go-MediatR/blob/main/LICENCE"><img alt="build-status" src="https://img.shields.io/github/license/mehdihadeli/Go-MediatR?color=%234275f5&style=flat-square"/></a>
    <a href="https://coveralls.io/github/mehdihadeli/Go-MediatR?branch=main"><img alt="Coverage Status" src="https://img.shields.io/coveralls/github/mehdihadeli/Go-MediatR?color=%23f542cb&style=flat-square"/></a>
    <a href="https://pkg.go.dev/github.com/mehdihadeli/go-mediatr"><img alt="build-status" src="https://pkg.go.dev/badge/github.com/mehdihadeli/go-mediatr"/></a>
  </div>
</div>

> This package is a `Mediator Pattern` implementation in golang, and inspired by great [jbogard/mediatr](https://github.com/jbogard/mediatr) library in .Net.

For decoupling some objects in a system we could use `Mediator` object as an interface, for decrease coupling between the objects. Mostly I uses this pattern when I use CQRS in my system.

There are some samples for using this package [here](internal/examples), also I used this packages widely in [this microservices sample](https://github.com/mehdihadeli/store-golang-microservices)

## 🧰 Installation

```bash
go get github.com/mehdihadeli/go-mediatr
```

## 🔥 Features
✅ Handling `Request/Response` message for delivering message to only one handler (Commands, Queries)

✅ Handling `Notification` message for delivering message to multiple handlers (Events)

✅ `Pipelenes Behaviours` for handling some cross cutting concerns before or after executing handlers 

## 🛡️ Strategies
Mediatr has two strategies for dispatching messages:

1. `Request/Response` messages, dispatched to a `single handler`.
2. `Notification` messages, dispatched to all (multiple) `handlers` and they don't have any response.

### Request/Response Strategy
The `request/response` message, has just `one handler`, and can handle both command and query scenarios in [CQRS Pattern](https://martinfowler.com/bliki/CQRS.html).

#### Creating a Request/Response Message

For creating a request (command or query) that has just `one handler`, we could create a command message or query message as a `request` like this:

```go
// Command (Request)
type CreateProductCommand struct {
    ProductID   uuid.UUID `validate:"required"`
    Name        string    `validate:"required,gte=0,lte=255"`
    Description string    `validate:"required,gte=0,lte=5000"`
    Price       float64   `validate:"required,gte=0"`
    CreatedAt   time.Time `validate:"required"`
}

// Query (Request)
type GetProdctByIdQuery struct {
    ProductID uuid.UUID `validate:"required"`
}
```
And for response of these requests, we could create response messages as a `response` like this:

```go
// Command (Response)
type CreateProductCommandResponse struct {
    ProductID uuid.UUID `json:"productId"`
}

// Query (Response)
type GetProductByIdQueryResponse struct {
    ProductID   uuid.UUID `json:"productId"`
    Name        string    `json:"name"`
    Description string    `json:"description"`
    Price       float64   `json:"price"`
    CreatedAt   time.Time `json:"createdAt"`
}
```

#### Creating Request Handler

For handling our requests, we should create a `single request handler` for each request. Each handler should implement the `RequestHandler` interface. 
```go
type RequestHandler[TRequest any, TResponse any] interface {
	Handle(ctx context.Context, request TRequest) (TResponse, error)
}
```

Here we Create `request handler` (command handler and query handler) for our requests, that implements above interface:

``` go
// Command Handler
type CreateProductCommandHandler struct {
	productRepository *repository.InMemoryProductRepository
}

func NewCreateProductCommandHandler(productRepository *repository.InMemoryProductRepository) *CreateProductCommandHandler {
	return &CreateProductCommandHandler{productRepository: productRepository}
}

func (c *CreateProductCommandHandler) Handle(ctx context.Context, command *CreateProductCommand) (*creatingProductDtos.CreateProductCommandResponse, error) {

	product := &models.Product{
		ProductID:   command.ProductID,
		Name:        command.Name,
		Description: command.Description,
		Price:       command.Price,
		CreatedAt:   command.CreatedAt,
	}

	createdProduct, err := c.productRepository.CreateProduct(ctx, product)
	if err != nil {
		return nil, err
	}

	response := &creatingProductDtos.CreateProductCommandResponse{ProductID: createdProduct.ProductID}

	return response, nil
}
```

```go
// Query Handler
type GetProductByIdQueryHandler struct {
    productRepository *repository.InMemoryProductRepository
}

func NewGetProductByIdQueryHandler(productRepository *repository.InMemoryProductRepository) *GetProductByIdQueryHandler {
    return &GetProductByIdQueryHandler{productRepository: productRepository}
}

func (c *GetProductByIdQueryHandler) Handle(ctx context.Context, query *GetProductByIdQuery) (*gettingProductDtos.GetProdctByIdQueryResponse, error) {

    product, err := c.productRepository.GetProductById(ctx, query.ProductID)
    if err != nil {
        return nil, err
    }

    response := &gettingProductDtos.GetProdctByIdQueryResponse{
        ProductID:   product.ProductID,
        Name:        product.Name,
        Description: product.Description,
        Price:       product.Price,
        CreatedAt:   product.CreatedAt,
    }

    return response, nil
}
```

> Note: In the cases we don't need a response from our request handler, we can use `Unit` type, that actually is an empty struct:.

#### Registering Request Handler to the MediatR
Before `sending` or `dispatching` our requests, we should `register` our request handlers to the MediatR.

Here we register our request handlers (command handler and query handler) to the MediatR:
```go
// Registering `createProductCommandHandler` request handler for `CreateProductCommand` request to the MediatR
mediatr.RegisterHandler[*creatingProduct.CreateProductCommand, *creatingProductsDtos.CreateProductCommandResponse](createProductCommandHandler)

// Registering `getProductByIdQueryHandler` request handler for `GetProductByIdQuery` request to the MediatR
mediatr.RegisterHandler[*gettingProduct.GetProductByIdQuery, *gettingProductDtos.GetProdctByIdQueryResponse](getProductByIdQueryHandler)
```

#### Sending Request to the MediatR

Finally, send a message through the mediator.

Here we send our requests to the MediatR for dispatching them to the request handlers (command handler and query handler):
``` go
// Sending `CreateProductCommand` request to mediatr for dispatching to the `CreateProductCommandHandler` request handler
command := &CreateProductCommand{
    ProductID:   uuid.NewV4(),
    Name:        request.name,
    Description: request.description,
    Price:       request.price,
    CreatedAt:   time.Now(),
}

mediatr.Send[*CreateProductCommand, *creatingProductsDtos.CreateProductCommandResponse](ctx, command)
```

```go
// Sending `GetProductByIdQuery` request to mediatr for dispatching to the `GetProductByIdQueryHandler` request handler
query := &GetProdctByIdQuery{
    ProductID:   uuid.NewV4()
}

mediatr.Send[*GetProductByIdQuery, *gettingProductsDtos.GetProductByIdQueryResponse](ctx, query)
```

### Notification Strategy

The `notification` message, can have `multiple handlers` and doesn't have any response, and it can handle an [event notification](https://martinfowler.com/articles/201701-event-driven.html) or notification in event driven architecture.

#### Creating a Notification Message

For creating a notification (event), that has multiple `handlers` and doesn't have any response, we could create an event notification as a `notification` like this:

```go
// Event (Notification)
type ProductCreatedEvent struct {
    ProductID uuid.UUID   `json:"productId"`
    Name        string    `json:"name"`
    Description string    `json:"description"`
    Price       float64   `json:"price"`
    CreatedAt   time.Time `json:"createdAt"`
}
```
This event doesn't have any response.

#### Creating Notification Handlers

For handling our notification, we can create `multiple notification handlers` for each notification event. Each handler should implement the `NotificationHandler` interface.
```go
type NotificationHandler[TNotification any] interface {
    Handle(ctx context.Context, notification TNotification) error
}
```

Here we Create multiple `notification event handler` for our notification, that implements above interface:

```go
// Notification Event Handler1
type ProductCreatedEventHandler1 struct {
}

func (c *ProductCreatedEventHandler1) Handle(ctx context.Context, event *ProductCreatedEvent) error {
//Do something with the event here !
    return nil
}
```

```go
// Notification Event Handler2
type ProductCreatedEventHandler2 struct {
}

func (c *ProductCreatedEventHandler2) Handle(ctx context.Context, event *ProductCreatedEvent) error {
//Do something with the event here !
    return nil
}
```

#### Registering Notification Handlers to the MediatR
Before `publishing` our notifications, we should `register` our notification handlers to the MediatR.

Here we register our notification handlers to the MediatR:
```go
// Registering `notificationHandler1`, `notificationHandler2` notification handler for `ProductCreatedEvent` notification event to the MediatR
notificationHandler1 := &ProductCreatedEventHandler1{}
notificationHandler2 := &ProductCreatedEventHandler2{}

mediatr.RegisterNotificationHandlers[*events.ProductCreatedEvent](notificationHandler1, notificationHandler2)
```

#### Publishing Notification to the MediatR
Finally, publish a notification event through the mediator.

Here we publish our notification to the MediatR for dispatching them to the notification handlers:
``` go
// Publishing `ProductCreatedEvent` notification to mediatr for dispatching to the `ProductCreatedEventHandler1`, `ProductCreatedEventHandler2` notification handlers
productCreatedEvent := 	&ProductCreatedEvent {
    ProductID:   createdProduct.ProductID,
    Name:        createdProduct.Name,
    Price:       createdProduct.Price,
    CreatedAt:   createdProduct.CreatedAt,
    Description: createdProduct.Description,
}
	
mediatr.Publish[*events.ProductCreatedEvent](ctx, productCreatedEvent)
```

## ⚒️ Using Pipeline Behaviors
Sometimes we need to add some cross-cutting concerns before after running our request handlers like logging, metrics, circuit breaker, retry, etc. In this case we can use `PipelineBehavior`. It is actually is like a middleware or [decorator pattern](https://refactoring.guru/design-patterns/decorator).

These behaviors will execute before or after running our request handlers with calling `Send` method for a request on the mediatr.

### Creating Pipeline Behavior
For creating a pipeline behaviour we should implement the `PipelineBehavior` interface:

``` go
type PipelineBehavior interface {
	Handle(ctx context.Context, request interface{}, next RequestHandlerFunc) (interface{}, error)
}
```
The `request` parameter is the request object passed in through `Send` method of mediatr, while the `next` parameter is a continuation for the next action in the behavior chain and its type is `RequestHandlerFunc`. 

Here is an example of a pipeline behavior:

```go
type RequestLoggerBehaviour struct {
}

func (r *RequestLoggerBehaviour) Handle(ctx context.Context, request interface{}, next mediatr.RequestHandlerFunc) (interface{}, error) {
	log.Printf("logging some stuff before handling the request")

	response, err := next()
	if err != nil {
		return nil, err
	}

	log.Println("logging some stuff after handling the request")

	return response, nil
}
```
In our defined behavior, we need to call `next` parameter that call next action in the behavior chain, if there aren't any other behaviours `next` will call our `actual request handler` and return the response. We can do something before of after of calling next action in the behavior chain.

### Registering Pipeline Behavior to the MediatR

For registering our pipeline behavior to the MediatR, we should use `RegisterPipelineBehaviors` method:

```go
loggerPipeline := &behaviours.RequestLoggerBehaviour{}
err = mediatr.RegisterRequestPipelineBehaviors(loggerPipeline)
```




Go-MediatR

RabbitMQ client with declarative configuration.

[![Build Status](https://github.com/cheshir/go-mq/actions/workflows/go.yml/badge.svg)](https://github.com/cheshir/go-mq/actions/workflows/go.yml)
[![codecov](https://codecov.io/gh/cheshir/go-mq/branch/master/graph/badge.svg)](https://codecov.io/gh/cheshir/go-mq)
[![Go Report Card](https://goreportcard.com/badge/cheshir/go-mq)](https://goreportcard.com/report/github.com/cheshir/go-mq)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=cheshir_go-mq&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=cheshir_go-mq) 
[![GoDoc](https://godoc.org/github.com/cheshir/go-mq?status.svg)](https://godoc.org/github.com/cheshir/go-mq)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/avelino/awesome-go)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/cheshir/go-mq/blob/master/LICENSE)


# About

This package provides an ability to encapsulate creation and configuration of RabbitMQ([AMQP])(https://www.amqp.org) entities 
like queues, exchanges, producers and consumers in a declarative way with a single config.

Exchanges, queues and producers are going to be initialized in the background.

go-mq supports both sync and async producers.

go-mq has auto reconnects on closed connection or network error.
You can configure delay between each connect try using `reconnect_delay` option.

### Minimal go version

1.16

## Install

`go get -u github.com/cheshir/go-mq/v2`

## API

Visit [godoc](https://godoc.org/github.com/cheshir/go-mq) to get information about library API.

For those of us who preferred learn something new on practice there is working examples in `example` directory.

## Configuration

You can configure mq using mq.Config struct directly or by filling it from config file.

Supported configuration tags:

* yaml
* json
* mapstructure

Available options:

```yaml
dsn: "amqp://login:password@host:port/virtual_host" # Use comma separated list for cluster connection
reconnect_delay: 5s                     # Interval between connection tries. Check https://golang.org/pkg/time/#ParseDuration for details.
test_mode: false                        # Switches library to use mocked broker. Defaults to false.
exchanges:
  - name: "exchange_name"
    type: "direct"
    options:
      # Available options with default values:
      auto_delete: false
      durable: false
      internal: false
      no_wait: false
queues:
  - name: "queue_name"
    exchange: "exchange_name"
    routing_key: "route"
    # A set of arguments for the binding.
    # The syntax and semantics of these arguments depend on the exchange class.
    binding_options:
      no_wait: false
    # Available options with default values:
    options:
      auto_delete: false
      durable: false
      exclusive: false
      no_wait: false
producers:
  - name: "producer_name"
    buffer_size: 10                      # Declare how many messages we can buffer during fat messages publishing.
    exchange: "exchange_name"
    routing_key: "route"
    sync: false                          # Specify whether producer will worked in sync or async mode.
    # Available options with default values:
    options:
      content_type:  "application/json"
      delivery_mode: 2                   # 1 - non persistent, 2 - persistent.
consumers:
  - name: "consumer_name"
    queue: "queue_name"
    workers: 1                           # Workers count. Defaults to 1.
    prefetch_count: 0                    # Prefetch message count per worker.
    prefetch_size: 0                     # Prefetch message size per worker.
    # Available options with default values:
    options:
      no_ack: false
      no_local: false
      no_wait: false
      exclusive: false
```

## Error handling

All errors are accessible via exported channel:

```go
package main

import (
	"log"

	"github.com/cheshir/go-mq"
)

func main() {
	config := mq.Config{} // Set your configuration.
	queue, _ := mq.New(config)
	// ...

	go handleMQErrors(queue.Error())
	
	// Other logic.
}

func handleMQErrors(errors <-chan error) {
	for err := range errors {
		log.Println(err)
	}
}
```

If channel is full – new errors will be dropped.

Errors from sync producer won't be accessible from error channel because they returned directly.

## Tests

There are some cases that can only be tested with real broker 
and some cases that can only be tested with mocked broker.
 
If you are able to run tests with a real broker run them with:

`go test -mock-broker=0`

Otherwise mock will be used.

## Changelog

Check [releases page](https://github.com/cheshir/go-mq/releases).

## How to upgrade

### From v1 to v2

* `New()` returns `*MessageQueue` not the interface.

* Minimal go version updated to the 1.16.

### From version 0.x to 1.x

* `GetConsumer()` method was renamed to `Consumer()`. This is done to follow go guideline.

* `GetProducer()` method was removed. Use instead `AsyncProducer()` or `SyncProducer()` if you want to catch net error by yourself.

## Epilogue

Feel free to create issues with bug reports or your wishes.


go-mq

Native implementation of the freedesktop notification spec.

# go-notify

[![PkgGoDev](https://pkg.go.dev/badge/github.com/TheCreeper/go-notify)](https://pkg.go.dev/github.com/TheCreeper/go-notify)

Package notify provides an implementation of the Gnome DBus
[Notifications Specification](https://developer.gnome.org/notification-spec).

## Examples

Display a simple notification.
```Go
ntf := notify.NewNotification("Test Notification", "Just a test")
if _, err := ntf.Show(); err != nil {
	return
}
```

Display a notification with an icon. Consult the
[Icon Naming Specification](http://standards.freedesktop.org/icon-naming-spec).
```Go
ntf := notify.NewNotification("Test Notification", "Just a test")
ntf.AppIcon = "network-wireless"
if _, err := ntf.Show(); err != nil {
	return
}
```

Display a notification that never expires.
```Go
ntf := notify.NewNotification("Test Notification", "Just a test")
ntf.Timeout = notify.ExpiresNever
if _, err := ntf.Show(); err != nil {
	return
}
```

Play a sound with the notification.
```Go
ntf := notify.NewNotification("Test Notification", "Just a test")
ntf.Hints = make(map[string]interface{})
ntf.Hints[notify.HintSoundFile] = "/home/my-username/sound.oga"
if _, err := ntf.Show(); err != nil {
	return
}
```


go-notify

## go-nsq

[![Build Status](https://github.com/nsqio/go-nsq/workflows/tests/badge.svg)](https://github.com/nsqio/go-nsq/actions) [![GoDoc](https://godoc.org/github.com/nsqio/go-nsq?status.svg)](https://godoc.org/github.com/nsqio/go-nsq) [![GitHub release](https://img.shields.io/github/release/nsqio/go-nsq.svg)](https://github.com/nsqio/go-nsq/releases/latest)

The official Go package for [NSQ][nsq].

### Docs

See [godoc][nsq_gopkgdoc] and the [main repo apps][apps] directory for examples of clients built
using this package.

### Tests

Tests are run via `./test.sh` (which requires `nsqd` and `nsqlookupd` to be installed).

[nsq]: https://github.com/nsqio/nsq
[nsq_gopkgdoc]: http://godoc.org/github.com/nsqio/go-nsq
[apps]: https://github.com/nsqio/nsq/tree/master/apps
[travis]: http://travis-ci.org/nsqio/go-nsq


go-nsq

Package for building REST/real-time services where clients are synchronized seamlessly, using NATS and Resgate.

<p align="center"><a href="https://resgate.io" target="_blank" rel="noopener noreferrer"><img width="100" src="https://resgate.io/img/resgate-logo.png" alt="Resgate logo"></a></p>
<h2 align="center"><b>RES Service for Go</b><br/>Synchronize Your Clients</h2>
<p align="center">
<a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
<a href="http://goreportcard.com/report/jirenius/go-res"><img src="http://goreportcard.com/badge/github.com/jirenius/go-res" alt="Report Card"></a>
<a href="https://github.com/jirenius/go-res/actions/workflows/build.yml?query=branch%3Amaster"><img src="https://img.shields.io/github/actions/workflow/status/jirenius/go-res/build.yml?branch=master" alt="Build Status"></a>
<a href="https://coveralls.io/github/jirenius/go-res?branch=master"><img src="https://coveralls.io/repos/github/jirenius/go-res/badge.svg?branch=master" alt="Coverage"></a>
<a href="https://pkg.go.dev/github.com/jirenius/go-res"><img src="https://img.shields.io/static/v1?label=reference&message=go.dev&color=5673ae" alt="Reference"></a>
</p>

---

[Go](http://golang.org) package used to create REST, real time, and RPC APIs, where all your reactive web clients are synchronized seamlessly through [Resgate](https://github.com/resgateio/resgate).

Visit [Resgate.io](https://resgate.io) for more information.

## Installation

```bash
go get github.com/jirenius/go-res
```

## As easy as

```go
package main

import res "github.com/jirenius/go-res"

func main() {
   s := res.NewService("example")
   s.Handle("model",
      res.Access(res.AccessGranted),
      res.GetModel(func(r res.ModelRequest) {
         r.Model(struct {
            Message string `json:"message"`
         }{"Hello, World!"})
      }),
   )
   s.ListenAndServe("nats://localhost:4222")
}
```
> **Prerequisite**
>
> [Install](https://resgate.io/docs/get-started/installation/) *NATS Server* and *Resgate*. Can be done with 3 docker commands:
> ```text
> docker network create res
> docker run -d --name nats -p 4222:4222 --net res nats
> docker run --name resgate -p 8080:8080 --net res resgateio/resgate --nats nats://nats:4222
> ```


## Examples

| Example | Description
| --- | ---
| [Hello World](examples/01-hello-world/) | Smallest of services serving a static message.
| [Edit Text](examples/02-edit-text/) | Single text field that is updated in real time.
| [Book Collection](examples/03-book-collection/) | List of book titles & authors that can be edited by many.
| [Book Collection Store](examples/04-book-collection-store/) | Book Collection example persisting changes using BadgerBD store.
| [Search Query](examples/05-search-query/) | Make live queries against a large customer database.

> **Note**
>
> Above examples are complete with both service and client.

## Usage

#### Create a new service

```go
s := res.NewService("myservice")
```

#### Add handlers for a model resource

```go
mymodel := map[string]interface{}{"name": "foo", "value": 42}
s.Handle("mymodel",
   res.Access(res.AccessGranted),
   res.GetModel(func(r res.ModelRequest) {
      r.Model(mymodel)
   }),
)
```

#### Add handlers for a collection resource

```go
mycollection := []string{"first", "second", "third"}
s.Handle("mycollection",
   res.Access(res.AccessGranted),
   res.GetCollection(func(r res.CollectionRequest) {
      r.Collection(mycollection)
   }),
)
```

#### Add handlers for parameterized resources

```go
s.Handle("article.$id",
   res.Access(res.AccessGranted),
   res.GetModel(func(r res.ModelRequest) {
      article := getArticle(r.PathParam("id"))
      if article == nil {
         r.NotFound()
      } else {
         r.Model(article)
      }
   }),
)
```

#### Add handlers for method calls

```go
s.Handle("math",
   res.Access(res.AccessGranted),
   res.Call("double", func(r res.CallRequest) {
      var p struct {
         Value int `json:"value"`
      }
      r.ParseParams(&p)
      r.OK(p.Value * 2)
   }),
)
```

#### Send change event on model update
A change event will update the model on all subscribing clients.

```go
s.With("myservice.mymodel", func(r res.Resource) {
   mymodel["name"] = "bar"
   r.ChangeEvent(map[string]interface{}{"name": "bar"})
})
```

#### Send add event on collection update:
An add event will update the collection on all subscribing clients.

```go
s.With("myservice.mycollection", func(r res.Resource) {
   mycollection = append(mycollection, "fourth")
   r.AddEvent("fourth", len(mycollection)-1)
})
```

#### Add handlers for authentication

```go
s.Handle("myauth",
   res.Auth("login", func(r res.AuthRequest) {
      var p struct {
         Password string `json:"password"`
      }
      r.ParseParams(&p)
      if p.Password != "mysecret" {
         r.InvalidParams("Wrong password")
      } else {
         r.TokenEvent(map[string]string{"user": "admin"})
         r.OK(nil)
      }
   }),
)
```

#### Add handlers for access control

```go
s.Handle("mymodel",
   res.Access(func(r res.AccessRequest) {
      var t struct {
         User string `json:"user"`
      }
      r.ParseToken(&t)
      if t.User == "admin" {
         r.AccessGranted()
      } else {
         r.AccessDenied()
      }
   }),
   res.GetModel(func(r res.ModelRequest) {
      r.Model(mymodel)
   }),
)
```

#### Using routes

```go
s.Route("v2", func(m *res.Mux) {
   m.Handle("mymodel",
      /* ... */
   )
})
```

#### Start service

```go
s.ListenAndServe("nats://localhost:4222")
```

## Testing [![Reference][godev]](https://pkg.go.dev/github.com/jirenius/go-res/restest)

The [restest](restest/) subpackage is used for testing services and validate responses.

## Inter-service communication [![Reference][godev]](https://pkg.go.dev/github.com/jirenius/go-res/resprot)

The [resprot](resprot/) subpackage provides low level structs and methods for communicating with other services over NATS server.

## Storage [![Reference][godev]](https://pkg.go.dev/github.com/jirenius/go-res/store)

The [store](store/) subpackage contains handlers and interfaces for working with database storage.

| Name | Description | Documentation
| --- | --- | ---
| [mockstore](store/mockstore/) | Mock store implementation for testing | [![Reference][godev]](https://pkg.go.dev/github.com/jirenius/go-res/store/mockstore)
| [badgerstore](store/badgerstore/) | BadgerDB store implementation | [![Reference][godev]](https://pkg.go.dev/github.com/jirenius/go-res/store/badgerstore)

## Credits

Inspiration on the go-res API has been taken from [github.com/go-chi/chi](https://github.com/go-chi/chi), a great package when writing ordinary HTTP services, and will continue to do so when it is time to implement Middleware, sub-handlers, and mounting.

## Contributing

The go-res package is still under development, but the API is mostly settled. Any feedback on the package API or its implementation is highly appreciated!

Once the API is fully settled, the package will be moved to the [resgateio](https://github.com/resgateio/) GitHub organization.

If you find any issues, feel free to [report them](https://github.com/jirenius/go-res/issues/new) as an issue.

[godev]: https://img.shields.io/static/v1?label=reference&message=go.dev&color=5673ae "Reference"


go-res

Push notification server using [APNs2](https://github.com/sideshow/apns2) and google [GCM](https://github.com/google/go-gcm).

gorush

A library for scheduling when to dispatch a message to a channel.

# gosd
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Build Status](https://travis-ci.com/alexsniffin/gosd.svg?branch=master)](https://travis-ci.com/alexsniffin/gosd)
[![Go Report Card](https://goreportcard.com/badge/github.com/alexsniffin/gosd)](https://goreportcard.com/report/github.com/alexsniffin/gosd)
[![codecov](https://codecov.io/gh/alexsniffin/gosd/branch/master/graph/badge.svg)](https://codecov.io/gh/alexsniffin/gosd)

go-schedulable-dispatcher (gosd), is a library for scheduling when to dispatch a message to a channel.

## Implementation
The implementation provides an interactive API to handle scheduling messages with a dispatcher. Messages are ingested and processed into a heap based priority queue. Order is not guaranteed by default when messages have the same scheduled time, but can be changed through the config. By guaranteeing order, performance will be slightly worse. If strict-ordering isn't critical to your application, it's recommended to keep the default setting.

## Example
```go
// create instance of dispatcher
dispatcher, err := gosd.NewDispatcher[string](&gosd.DispatcherConfig{
    IngressChannelSize:  100,
    DispatchChannelSize: 100,
    MaxMessages:         100,
    GuaranteeOrder:      false,
})
checkErr(err)

// spawn process
go dispatcher.Start()

// schedule a message
dispatcher.IngressChannel() <- &gosd.ScheduledMessage[string]{
    At:      time.Now().Add(1 * time.Second),
    Message: "Hello World in 1 second!",
}

// wait for the message
msg := <-dispatcher.DispatchChannel()

fmt.Println(msg)
// Hello World in 1 second!

// shutdown without deadline
dispatcher.Shutdown(context.Background(), false)
```

More examples under [examples](examples).

## Benchmarking
Tested with Go 1.19 and 1000 messages per iteration.
```
goos: windows
goarch: amd64
pkg: github.com/alexsniffin/gosd/v2
cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
Benchmark_integration_unordered
Benchmark_integration_unordered-12                           307           3690528 ns/op
Benchmark_integration_unorderedSmallBuffer
Benchmark_integration_unorderedSmallBuffer-12                274           4120104 ns/op
Benchmark_integration_unorderedSmallHeap
Benchmark_integration_unorderedSmallHeap-12                  348           3452703 ns/op
Benchmark_integration_ordered
Benchmark_integration_ordered-12                             135           8650709 ns/op
Benchmark_integration_orderedSmallBuffer
Benchmark_integration_orderedSmallBuffer-12                  207           5867338 ns/op
Benchmark_integration_orderedSmallHeap
Benchmark_integration_orderedSmallHeap-12                    350           3592990 ns/op
Benchmark_integration_orderedSameTime
Benchmark_integration_orderedSameTime-12                     133           8909311 ns/op
```


gosd

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.

# Guble Messaging Server

Guble is a simple user-facing messaging and data replication server written in Go.

[![Codacy Badge](https://api.codacy.com/project/badge/Grade/f3b9a351201b416db4fe6df8faea363b)](https://www.codacy.com/app/cosminrentea/guble?utm_source=github.com&utm_medium=referral&utm_content=smancke/guble&utm_campaign=badger)
[![Release](https://img.shields.io/github/release/smancke/guble.svg)](https://github.com/smancke/guble/releases/latest)
[![Docker](https://img.shields.io/docker/pulls/smancke/guble.svg)](https://hub.docker.com/r/smancke/guble/)
[![Build Status](https://api.travis-ci.org/smancke/guble.svg?branch=master)](https://travis-ci.org/smancke/guble)
[![Go Report Card](https://goreportcard.com/badge/github.com/smancke/guble)](https://goreportcard.com/report/github.com/smancke/guble)
[![codebeat badge](https://codebeat.co/badges/7f317892-0a7b-4e31-97f4-a530cf779889)](https://codebeat.co/projects/github-com-smancke-guble)
[![Coverage Status](https://coveralls.io/repos/smancke/guble/badge.svg?branch=master&service=github)](https://coveralls.io/github/smancke/guble?branch=master)
[![GoDoc](https://godoc.org/github.com/smancke/guble?status.svg)](https://godoc.org/github.com/smancke/guble)
[![Awesome-Go](https://camo.githubusercontent.com/13c4e50d88df7178ae1882a203ed57b641674f94/68747470733a2f2f63646e2e7261776769742e636f6d2f73696e647265736f726875732f617765736f6d652f643733303566333864323966656437386661383536353265336136336531353464643865383832392f6d656469612f62616467652e737667)](https://awesome-go.com)

# Overview
Guble is in an early state (release 0.4). 
It is already working well and is very useful, but the protocol, API and storage formats 
may still change (until reaching 0.7). 
If you intend to use guble, please get in contact with us.

The goal of guble is to be a simple and fast message bus for user interaction and replication of data between multiple devices:
* Very easy consumption of messages with web and mobile clients
* Fast realtime messaging, as well as playback of messages from a persistent commit log
* Reliable and scalable over multiple nodes
* User-aware semantics to easily support messaging scenarios between people using multiple devices
* Batteries included: usable as front-facing server, without the need of a proxy layer
* Self-contained: no mandatory dependencies to other services

## Working Features (0.4)

* Publishing and subscription of messages to topics and subtopics
* Persistent message store with transparent live and offline fetching
* WebSocket and REST APIs for message publishing
* Commandline client and Go client library
* Firebase Cloud Messaging (FCM) adapter: delivery of messages as FCM push notifications
* Docker images for server and client
* Simple Authentication and Access-Management
* Clean shutdown
* Improved logging using [logrus](https://github.com/Sirupsen/logrus) and logstash formatter
* Health-Check with Endpoint
* Collection of Basic Metrics, with Endpoint
* Added Postgresql as KV Backend
* Load testing with 5000 messages per instance
* Support for Apple Push Notification services (a new connector alongside Firebase)
* Upgrade, cleanup, abstraction, documentation, and test coverage of the Firebase connector
* GET list of subscribers / list of topics per subscriber (userID , deviceID) 
* Support for SMS-sending using Nexmo (a new connector alongside Firebase)

## Throughput
Measured on an old notebook with i5-2520M, dual core and SSD. Message payload was 'Hello Word'.
Load driver and server were set up on the same machine, so 50% of the cpu was allocated to the load driver.

* End-2-End: Delivery of ~35.000 persistent messages per second
* Fetching: Receive of ~70.000 persistent messages per second

During the tests, the memory consumption of the server was around ~25 MB.

## Table of Contents

- [Roadmap](#roadmap)
  - [Roadmap Release 0.5](#roadmap-release-05)
  - [Roadmap Release 0.6](#roadmap-release-06)
  - [Roadmap Release 0.7](#roadmap-release-07)
- [Guble Docker Image](#guble-docker-image)
  - [Start the Guble Server](#start-the-guble-server)
  - [Connecting with the Guble Client](#connecting-with-the-guble-client)
- [Build and Run](#build-and-run)
  - [Build and Start the Server](#build-and-start-the-server)
    - [Configuration](#configuration)
  - [Run All Tests](#run-all-tests)
- [Clients](#clients)
- [Protocol Reference](#protocol-reference)
  - [REST API](#rest-api)
    - [Headers](#headers)
  - [WebSocket Protocol](#websocket-protocol)
    - [Message Format](#message-format)
    - [Client Commands](#client-commands)
    - [Server Status Messages](#server-status-messages)
  - [Topics](#topics)
    - [Subtopics](#subtopics)

# Roadmap
This is the current (and fast changing) roadmap and todo list:

## Roadmap Release 0.5
* Replication across multiple servers (in a Guble cluster)
* Acknowledgement of message delivery for connectors
* Storing the sequence-Id of topics in KV store, if we turn off persistence
* Filtering of messages in guble server (e.g. sent by the REST client) according to URL parameters: UserID, DeviceID, Connector name
* Updating README to show subscribe/unsubscribe/get/posting, health/metrics 

## Roadmap Release 0.6
* Make notification messages optional by client configuration
* Correct behaviour of receive command with `maxCount` on subtopics
* Cancel of fetch in the message store and multiple concurrent fetch commands for the same topic
* Configuration of different persistence strategies for topics
* Delivery semantics: user must read on one device / deliver only to one device / notify if not connected, etc.
* User-specific persistent subscriptions across all clients of the user
* Client: (re-)setup of subscriptions after client reconnect
* Message size limit configurable by the client with fetching by URL

## Roadmap Release 0.7
* HTTPS support in the service
* Minimal example: chat application
* Stable JavaScript client: https://github.com/smancke/guble-js
* (TBD) Improved authentication and access-management
* (TBD) Add Consul as KV Backend
* (TBD) Index-based search of messages using [GoLucene](https://github.com/balzaczyy/golucene)

# Guble Docker Image
We are providing Docker images of the server and client for your convenience.

## Start the Guble Server
There is an automated Docker build for the master at the Docker Hub.
To start the server with Docker simply type:
```
docker run -p 8080:8080 smancke/guble
```

To see available configuration options:
```
docker run smancke/guble --help
```

All options can be supplied on the commandline or by a corresponding environment variable with the prefix `GUBLE_`.
So to let guble be more verbose, you can either use:
```
docker run smancke/guble --log=info
```
or
```
docker run -e GUBLE_LOG=info smancke/guble
```

The Docker image has a volume mount point at `/var/lib/guble`, so if you want to bind-mount the persistent storage from your host you should use:
```
docker run -p 8080:8080 -v /host/storage/path:/var/lib/guble smancke/guble
```

## Connecting with the Guble Client
The Docker image includes the guble commandline client `guble-cli`.
You can execute it within a running guble container and connect to the server:
```
docker run -d --name guble smancke/guble
docker exec -it guble /usr/local/bin/guble-cli
```
Visit the [`guble-cli` documentation](https://github.com/smancke/guble/tree/master/guble-cli) for more details.

# Build and Run
Since Go makes it very easy to build from source, you can compile guble using a single command.
A prerequisite is having an installed Go environment and an empty directory:
```
sudo apt-get install golang
mkdir guble && cd guble
export GOPATH=`pwd`
```

## Build and Start the Server
Build and start guble with the following commands (assuming that directory `/var/lib/guble` is already created with read-write rights for the current user):
```
go get github.com/smancke/guble
bin/guble --log=info
```

### Configuration

|CLI Option|Env Variable|Values|Default|Description|
|--- |--- |--- |--- |--- |
|`--env`|GUBLE_ENV|development &#124; integration &#124; preproduction &#124; production|development|Name of the environment on which the application is running. Used mainly for logging|
|`--health-endpoint`|GUBLE_HEALTH_ENDPOINT|resource/path/to/healthendpoint|/admin/healthcheck|The health endpoint to be used by the HTTP server.Can be disabled by setting the value to ""|
|`--http`|GUBLE_HTTP_LISTEN|format: [host]:port||The address to for the HTTP server to listen on|
|`--kvs`|GUBLE_KVS|memory &#124; file &#124; postgres|file|The storage backend for the key-value store to use|
|`--log`|GUBLE_LOG|panic &#124; fatal &#124; error &#124; warn &#124; info &#124; debug|error|The log level in which the process logs|
|`--metrics-endpoint`|GUBLE_METRICS_ENDPOINT|resource/path/to/metricsendpoint|/admin/metrics|The metrics endpoint to be used by the HTTP server.Can be disabled by setting the value to ""|
|`--ms`|GUBLE_MS|memory &#124; file|file|The message storage backend|
|`--profile`|GUBLE_PROFILE|cpu &#124; mem &#124; block||The profiler to be used|
|`--storage-path`|GUBLE_STORAGE_PATH|path/to/storage|/var/lib/guble|The path for storing messages and key-value data like subscriptions if defined.The path must exists!|


#### APNS

|CLI Option|Env Variable|Values|Default|Description|
|--- |--- |--- |--- |--- |
|`--apns`|GUBLE_APNS|true &#124; false|false|Enable the APNS module in general as well as the connector to the development endpoint|
|`--apns-production`|GUBLE_APNS_PRODUCTION|true &#124; false|false|Enables the connector to the apns production endpoint, requires the apns option to be set|
|`--apns-cert-file`|GUBLE_APNS_CERT_FILE|path/to/cert/file||The APNS certificate file name, use this as an alternative to the certificate bytes option|
|`--apns-cert-bytes`|GUBLE_APNS_CERT_BYTES|cert-bytes-as-hex-string||The APNS certificate bytes, use this as an alternative to the certificate file option|
|`--apns-cert-password`|GUBLE_APNS_CERT_PASSWORD|password||The APNS certificate password|
|`--apns-app-topic`|GUBLE_APNS_APP_TOPIC|topic||The APNS topic (as used by the mobile application)|
|`--apns-prefix`|GUBLE_APNS_PREFIX|prefix|/apns/|The APNS prefix / endpoint|
|`--apns-workers`|GUBLE_APNS_WORKERS|number of workers|Number of CPUs|The number of workers handling traffic with APNS (default: number of CPUs)|


#### SMS

|CLI Option|Env Variable|Values|Default |Description|
|--- |--- |--- |--- |--- |
|`sms`|GUBLE_SMS|true &#124; false|false |Enable the SMS gateway|
|`sms_api_key`|GUBLE_SMS_API_KEY|api key||The Nexmo API Key for Sending sms|
|`sms_api_secret`|GUBLE_SMS_API_SECRET|api secret||The Nexmo API Secret for Sending sms|
|`sms_topic`|GUBLE_SMS_TOPIC|topic|/sms|The topic for sms route|
|`sms_workers`|GUBLE_SMS_WORKERS|number of workers|Number of CPUs|The number of workers handling traffic with Nexmo sms endpoint|

#### FCM

|CLI Option|Env Variable|Values|Default|Description|
|--- |--- |--- |--- |--- |
|`--fcm|GUBLE_FCM`|true &#124; false|false|Enable the Google Firebase Cloud Messaging connector|
|`--fcm-api-key`|GUBLE_FCM_API_KEY|api key||The Google API Key for Google Firebase Cloud Messaging|
|`--fcm-workers`|GUBLE_FCM_WORKERS|number of workers|Number of CPUs|The number of workers handling traffic with Firebase Cloud Messaging|
|`--fcm-endpoint`|GUBLE_FCM_ENDPOINT|format: url-schema|https://fcm.googleapis.com/fcm/send|The Google Firebase Cloud Messaging endpoint|
|`--fcm-prefix`|GUBLE_FCM_PREFIX|prefix|/fcm/|The FCM prefix / endpoint|

#### Postgres

|CLI Option|Env Variable|Values|Default|Description|
|--- |--- |--- |--- |--- |
|`--pg-host`|GUBLE_PG_HOST|hostname|localhost|The PostgreSQL hostname|
|`--pg-port`|GUBLE_PG_PORT|port|5432|The PostgreSQL port|
|`--pg-user`|GUBLE_PG_USER|user|guble|The PostgreSQL user|
|`--pg-password`|GUBLE_PG_PASSWORD|password|guble|The PostgreSQL password|
|`--pg-dbname`|GUBLE_PG_DBNAME|database|guble|The PostgreSQL database name|


## Run All Tests
```
go get -t github.com/smancke/guble/...
go test github.com/smancke/guble/...
```

# Clients
The following clients are available:
* __Commandline Client__: https://github.com/smancke/guble/tree/master/guble-cli
* __Go client library__: https://github.com/smancke/guble/tree/master/client
* __JavaScript library__: (in early stage) https://github.com/smancke/guble-js

# Protocol Reference

## REST API
Currently there is a minimalistic REST API, just for publishing messages.

```
POST /api/message/<topic>
```
URL parameters:
* __userId__: The PublisherUserId
* __messageId__: The PublisherMessageId

### Headers
You can set fields in the header JSON of the message by providing the corresponding HTTP headers with the prefix `X-Guble-`.

Curl example with the resulting message:
```
curl -X POST -H "x-Guble-Key: Value" --data Hello 'http://127.0.0.1:8080/api/message/foo?userId=marvin&messageId=42'
```
Results in:
```
16,/foo,marvin,VoAdxGO3DBEn8vv8,42,1451236804
{"Key":"Value"}
Hello
```

## WebSocket Protocol
The communication with the guble server is done by ordinary WebSockets, using a binary encoding.

### Message Format
All payload messages sent from the server to the client are using the following format:
```
<path:string>,<sequenceId:int64>,<publisherUserId:string>,<publisherApplicationId:string>,<publisherMessageId:string>,<messagePublishingTime:unix-timestamp>\n
[<application headers json>]\n
<body>

example 1:
/foo/bar,42,user01,phone1,id123,1420110000
{"Content-Type": "text/plain", "Correlation-Id": "7sdks723ksgqn"}
Hello World

example 2:
/foo/bar,42,user01,54sdcj8sd7,id123,1420110000

anyByteData
```

* All text formats are assumed to be UTF-8 encoded.
* Message `sequenceId`s are `int64`, and distinct within a topic.
  The message `sequenceId`s are strictly monotonically increasing depending on the message age, but there is no guarantee for the right order while transmitting.

### Client Commands
The client can send the following commands.

#### Send
Publish a message to a topic:
```
> <path> [<publisherMessageId>]\n
[<header>\n]..
\n
<body>

example:
> /foo

Hello World
```

#### Subscribe/Receive
Receive messages from a path (e.g. a topic or subtopic).
This command can be used to subscribe for incoming messages on a topic,
as well as for replaying the message history.
```
+ <path> [<startId>[,<maxCount>]]
```
* `path`: the topic to receive the messages from
* `startId`: the message id to start the replay
** If no `startId` is given, only future messages will be received (simple subscribe).
** If the `startId` is negative, it is interpreted as relative count of last messages in the history.
* `maxCount`: the maximum number of messages to replay

__Note__: Currently, the fetching of stored messages does not recognize subtopics.

Examples:
```
+ /foo         # Subscribe to all future messages matching /foo
+ /foo/bar     # Subscribe to all future messages matching /foo/bar

+ /foo 0       # Receive all message from the topic and subscribe for further incoming messages.

+ /foo 42      # Receive all message with message ids >= 42
               # from the topic and subscribe for further incoming messages.

+ /foo 0 20    # Receive the first (oldest) 20 messages within the topic and stop.
               # (If the topic has less messages, it will stop after receiving all existing ones.)

+ /foo -20     # Receive the last (newest) 20 messages from the topic and then
               # subscribe for further incoming messages.

+ /foo -20 20  # Receive the last (newest) 20 messages within the topic and stop.
               # (If the topic has less messages, it will stop after receiving all existing ones.)
```

#### Unsubscribe/Cancel
Cancel further receiving of messages from a path (e.g. a topic or subtopic).

```
- <path>

example:
- /foo
- /foo/bar
```

### Server Status Messages
The server sends status messages to the client. All positive status messages start with `>`.
Status messages reporting an error start with `!`. Status messages are in the following format.

```
'#'<msgType> <Explanation text>\n
<json data>
```

#### Connection Message
```
#ok-connected You are connected to the server.\n
{"ApplicationId": "the app id", "UserId": "the user id", "Time": "the server time as unix timestamp "}
```

Example:
```
#connected You are connected to the server.
{"ApplicationId": "phone1", "UserId": "user01", "Time": "1420110000"}
```

#### Send Success Notification
This notification confirms, that the messaging system has successfully received the message and now starts transmitting it to the subscribers:

```
#send <publisherMessageId>
{"sequenceId": "sequence id", "path": "/foo", "publisherMessageId": "publishers message id", "messagePublishingTime": "unix-timestamp"}
```

#### Receive Success Notification
Depending on the type of `+` (receive) command, up to three different notification messages will be sent back.
Be aware, that a server may send more receive notifications that you would have expected in first place, e.g. when:
* Additional messages are stored, while the first fetching is in progress
* The server decides to meanwhile stop the online subscription and change to fetching,
  because your client is too slow to read all incoming messages.

1. When the fetch operation starts:

    ```
    #fetch-start <path> <count>
    ```
    * `path`: the topic path
    * `count`: the number of messages that will be returned

2. When the fetch operation is done:

    ```
    #fetch-done <path>
    ```
    * `path`: the topic path
3. When the subscription to new messages was taken:

    ```
    #subscribed-to <path>
    ```
    * `path`: the topic path

#### Unsubscribe Success Notification
An unsubscribe/cancel operation is confirmed by the following notification:
```
#canceled <path>
```

#### Send Error Notification
This message indicates, that the message could not be delivered.
```
!error-send <publisherMessageId> <error text>
{"sequenceId": "sequence id", "path": "/foo", "publisherMessageId": "publishers message id", "messagePublishingTime": "unix-timestamp"}
```

#### Bad Request
This notification has the same meaning as the http 400 Bad Request.
```
!error-bad-request unknown command 'sdcsd'
```

#### Internal Server Error
This notification has the same meaning as the http 500 Internal Server Error.
```
!error-server-internal this computing node has problems
```

## Topics

Messages can be hierarchically routed by topics, so they are represented by a path, separated by `/`.
The server takes care, that a message only gets delivered once, even if it is matched by multiple
subscription paths.

### Subtopics
The path delimiter gives the semantic of subtopics. 
With this, a subscription to a parent topic (e.g. `/foo`)
also results in receiving all messages of the subtopics (e.g. `/foo/bar`).


guble

A user friendly library for sending messages and listening to TCP sockets.

# Hare Sockets 🐇

<img align="right" width="159px" src="./resources/images/small-icon.png">

![Go](https://github.com/leozz37/hare/workflows/Go/badge.svg)
[![codecov](https://codecov.io/gh/leozz37/hare/branch/main/graph/badge.svg?token=QC44PEpHRi)](https://codecov.io/gh/leozz37/hare)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Go Report Card](https://goreportcard.com/badge/github.com/leozz37/hare)](https://goreportcard.com/report/github.com/leozz37/hare)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/4a5488c02fd6481d826512536181a1eb)](https://app.codacy.com/gh/leozz37/hare?utm_source=github.com&utm_medium=referral&utm_content=leozz37/hare&utm_campaign=Badge_Grade)
[![Maintainability](https://api.codeclimate.com/v1/badges/97a96b7d488b201aab7c/maintainability)](https://codeclimate.com/github/leozz37/hare/maintainability)
[![GoDoc](https://pkg.go.dev/badge/github.com/leozz37/hare?status.svg)](https://pkg.go.dev/github.com/leozz37/hare?tab=doc)
[![Join the chat at https://gitter.im/hare-sockets/community](https://badges.gitter.im/hare-sockets/community.svg)](https://gitter.im/hare-sockets/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Release](https://img.shields.io/github/v/release/leozz37/hare)](https://github.com/leozz37/hare/releases)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Hare is an user-friendly package for sockets in Golang and a CLI tool for sockets interaction. You can send and listen to TCP connections with a few lines of code or commands.

## Contents

- [Installation](#installation)
- [Quickstart](#quickstart)
- [Documentation](#documentation)
- [Examples](#examples)
- [Testing](#testing)
- [Contributing](#contributing)
- [License](#license)

## 🖥️ Installation

Installation guide for the CLI Tool and Golang Library.

### 💻 CLI Tool

To install the CLI tool, you can install it through [Homebrew](https://brew.sh/):

```shell
$ brew tap leozz37/hare

$ brew install hare
```

Or you can install manually with the `Makefile` script:

```shell
$ make install
```

### 🐇 Golang Lib

First, you need [Go](https://golang.org/) (version 1.12+ is required), then you can install Hare:

```shell
$ go get -u "github.com/leozz37/hare"
```

Import it in your code:

```shell
import "github.com/leozz37/hare"
```

## 🍕 Quickstart

Quick start for the CLI Tool and the Golang Library.

### 💻 CLI Tool

To use the CLI tool, these are the flags:

```
  -d string
        Data to be sended
  -h string
        Host address to bo operated (default "localhost")
  -l    Listen to a given address
  -p string
        Port address to bo operated         [REQUIRED]
  -s    Send message to a given address
```

You can run the `--help`  flag:

```shell
$ hare --help
```

To `Listen` to port `3000` for example, run:

```shell
$ hare -l -p 3000
```

To `Send` a payload with the message `Hello World` to port `3000` for example, run:

```shell
$ hare -s -p 3000 -d 'Hello World'
```

![cli-example](resources/images/cli-example.png)

### 🐇 Golang Lib

[Sample code](./examples/send.go) for sending payloads:

```go
package main

import (
    "github.com/leozz37/hare"
)

func main() {
    hare.Send(3000, "Hello, World")
}
```

[Sample code](./examples/listen.go) for listening a port:

```go
package main

import (
    "fmt"

    "github.com/leozz37/hare"
)

func main() {
    r, _ := hare.Listen("3000")

    for {
        if r.HasNewMessages() {
            fmt.Println(r.GetMessage())
        }
    }
}
```

## 📖 Documentation

The library consists of two features: **listen** and **send** to a given port. You can check the full documentation on [Godoc](https://pkg.go.dev/github.com/leozz37/hare#section-documentation).

### Send

Receives a `port` and a `message`, both as `string` and returns an `error` (if something goes wrong).

```go
func Send(port, message string) error;
```

Usage example:

```go
func main() {
    err := hare.Send(3000, "Hello, World")
    if err != nil {
        panic(err)
    }
}
```

---

### Listen

Receives a `port` as `string` and returns a `Listener` struct and an `error` (if something goes wrong).

```go
func Listen(port string) (*Listener, error);
```

Usage example:

```go
func main() {
    r, _ := hare.Listen("3000")
    l, _ := hare.listen("3001")

    for {
        if r.HasNewMessages() {
            fmt.Println(r.GetMessage())
        } else if l.HasNewMessages() {
            fmt.Println(l.GetMessage())
        }
    }
```

---

### Listener

The **Listener** struct returned by `Listen()` function has the following fields:

```go
type Listener struct {
    SocketListener net.Listener
    HasNewMessages func() bool
    GetMessage     func() string
    Stop           func()
}
```

`SocketListener` is the socket connection.

```go
listener.SocketListener, _ = net.Listen("tcp", "localhost:" + port)
```

`HasNewMessages()` function returns a `bool` being `true` with there's a new message:

```go
func main() {
    r, _ := hare.Listen("3000")

    if r.HasNewMessages() {
        fmt.Println("There's a new message!")
    }
}
```

`GetMessage()` function returns a `string` with the last message received on the socket:

```go
func main() {
    r, _ := hare.Listen("3000")

    if r.HasNewMessages() {
        fmt.Println(r.GetMessage())
    }
}
```

`Stop()` function closes the listener connection:

```go
func main() {
    r, _ := hare.Listen("3000")
    hare.Send("3000", "Hey beauty")

    r.Stop()

    err := Send("3000", "This should fails")
    if err != nil {
        panic(err)
    }
}
```

## 📙 Examples

You can check the [example](./examples) for code usages, like [send](./examples/send.go) and [listen](./examples/listen.go) samples.

Since Hare only listens and send messages, here's a complete example:

```go
package main

import (
    "fmt"
    "time"

    "github.com/leozz37/hare"
)

func listenSockets(port string) {
    r, _ := hare.Listen(port)

    for {
        if r.HasNewMessages() {
            fmt.Println(r.GetMessage())
        }
    }
}

func main() {
    go listenSockets("3000")
    go listenSockets("3001")

    for {
        hare.Send("3000", "Hello port 3000")
        hare.Send("3001", "Hello port 3001")
        time.Sleep(time.Second)
    }
}
```

## 🧪 Testing

To run the test suite, you can run with:

```shell
$ go test
```

If you want a more detailed report with coverage and an `coverage.out` file, do the following:

```shell
$ go test -v -covermode=count -coverprofile=coverage.out
```

## 🤝 Contributing

A full guideline about contributing to Hare can be found in the [CONTRIBUTING.md](./CONTRIBUTING.md) file.

## ⚖️ License

Hare is released under the [MIT License](./LICENSE).


hare

A Message/Event Hub for Go applications, using publish/subscribe pattern with support for alias like rabbitMQ exchanges.

# Hub

:incoming_envelope: A fast enough Event Hub for go applications using publish/subscribe with support patterns on topics like rabbitMQ exchanges.

[![Release](https://img.shields.io/github/release/leandro-lugaresi/hub.svg?style=flat-square)](https://github.com/leandro-lugaresi/hub/releases/latest)
[![Software License](https://img.shields.io/github/license/leandro-lugaresi/hub.svg?style=flat-square)](LICENSE.md)
[![Actions Status](https://github.com/leandro-lugaresi/hub/workflows/Go/badge.svg)](https://github.com/leandro-lugaresi/hub/actions)
[![Coverage Status](https://img.shields.io/codecov/c/github/leandro-lugaresi/hub/main.svg?style=flat-square)](https://codecov.io/gh/leandro-lugaresi/hub)
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/leandro-lugaresi/hub)
[![Go Report Card](https://goreportcard.com/badge/github.com/leandro-lugaresi/hub?style=flat-square)](https://goreportcard.com/report/github.com/leandro-lugaresi/hub)
[![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/leandro-lugaresi)

---

## Table of Contents

- [Install](#install)
- [Usage](#usage)
- [Examples & Demos](#examples--demos)
- [Benchmarks](#benchmarks)
- [CSTrie](#cstrie)
- [Contribute](CONTRIBUTING.md)
- [Code of conduct](CODE_OF_CONDUCT.md)

## Install

To install this library you can `go get` it but I encourage you to always vendor your dependencies or use one of the version tags of this project.

```sh
go get -u github.com/leandro-lugaresi/hub
```

```sh
dep ensure --add github.com/leandro-lugaresi/hub
```

## Usage

### Subscribers

Hub provides subscribers as buffered (cap > `0`) and unbuffered (cap = 0) channels but we have two different types of subscribers:

- `Subscriber` this is the default subscriber and it's a blocking subscriber so if the channel is full and you try to send another message the send operation will block until the subscriber consumes some message.
- `NonBlockingSubscriber` this subscriber will never block on the publish side but if the capacity of the channel is reached the publish operation will be lost and an alert will be trigged.
  This should be used only if loose data is acceptable. ie: metrics, logs

### Topics

This library uses the same concept of topic exchanges on rabbiMQ, so the message name is used to find all the subscribers that match the topic, like a route.
The topic must be a list of words delimited by dots (`.`) however, there is one important special case for binding keys:
`*` (star) can substitute for exactly one word.

## Examples & Demos

```go
package main

import (
	"fmt"
	"sync"

	"github.com/leandro-lugaresi/hub"
)
func main() {
	h := hub.New()
	var wg sync.WaitGroup
	// the cap param is used to create one buffered channel with cap = 10
	// If you wan an unbuferred channel use the 0 cap
	sub := h.Subscribe(10, "account.login.*", "account.changepassword.*")
	wg.Add(1)
	go func(s hub.Subscription) {
		for msg := range s.Receiver {
			fmt.Printf("receive msg with topic %s and id %d\n", msg.Name, msg.Fields["id"])
		}
		wg.Done()
	}(sub)

	h.Publish(hub.Message{
		Name:   "account.login.failed",
		Fields: hub.Fields{"id": 123},
	})
	h.Publish(hub.Message{
		Name:   "account.changepassword.failed",
		Fields: hub.Fields{"id": 456},
	})
	h.Publish(hub.Message{
		Name:   "account.login.success",
		Fields: hub.Fields{"id": 123},
	})
	// message not routed to this subscriber
	h.Publish(hub.Message{
		Name:   "account.foo.failed",
		Fields: hub.Fields{"id": 789},
	})

	// close all the subscribers
	h.Close()
	// wait until finish all the messages on buffer
	wg.Wait()

	// Output:
	// receive msg with topic account.login.failed and id 123
	// receive msg with topic account.changepassword.failed and id 456
	// receive msg with topic account.login.success and id 123
}
```

See more [here](https://godoc.org/github.com/leandro-lugaresi/hub#example-Hub)!

## Benchmarks

To run the benchmarks you can execute:

```bash
make bench
```

Currently, I only have the benchmarks of the CSTrie used internally. I will provide more benchmarks.

## Throughput

The project have one test for throughput, just execute:

```bash
make throughput
```

In a intel(R) core(TM) i5-4460 CPU @ 3.20GHz x4 we got this results:

```
go test -v -timeout 60s github.com/leandro-lugaresi/hub -run ^TestThroughput -args -throughput
=== RUN   TestThroughput
1317530.091292 msg/sec
--- PASS: TestThroughput (3.04s)
PASS
ok      github.com/leandro-lugaresi/hub 3.192s
```

## CSTrie

This project uses internally an awesome Concurrent Subscription Trie done by [@tylertreat](https://github.com/tylertreat). If you want to learn more about see this [blog post](http://bravenewgeek.com/fast-topic-matching/) and the code is [here](https://github.com/tylertreat/fast-topic-matching)

---

This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.
We appreciate your contribution. Please refer to our [contributing guidelines](CONTRIBUTING.md) for further information


A very fast and efficient Go library for matching events to a large set of rules

[![SIT](https://img.shields.io/badge/SIT-awesome-blueviolet.svg)](https://jobs.schwarz)
[![CI](https://github.com/SchwarzIT/hypermatch/actions/workflows/go-test.yml/badge.svg)](https://github.com/SchwarzIT/hypermatch/actions/workflows/go-test.yml)
[![Coverage Status](https://coveralls.io/repos/github/SchwarzIT/hypermatch/badge.svg?branch=main)](https://coveralls.io/github/SchwarzIT/hypermatch?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/SchwarzIT/hypermatch)](https://goreportcard.com/report/github.com/SchwarzIT/hypermatch)
[![Go Reference](https://pkg.go.dev/badge/github.com/schwarzit/hypermatch.svg)](https://pkg.go.dev/github.com/schwarzit/hypermatch)
![License](https://img.shields.io/github/license/SchwarzIT/hypermatch)
![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/SchwarzIT/hypermatch)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)  

![hypermatch logo](./logo/logo-small.png)

# Introduction
Hypermatch is a high-performance Go library that enables rapid matching of a large number of rules against events. Designed for speed and efficiency, hypermatch handles thousands of events per second with low latency, making it ideal for real-time systems.

- **Fast Matching**: Matches events to a large set of rules in-memory with minimal delay  ... [it's really fast! (Benchmark)](_benchmark/benchmark.md)
- **Readable Rule Format**: Serialize rules into human-readable JSON objects.
- **Flexible Rule Syntax**: Supports various matching conditions, including equals, prefix, suffix, wildcard, anything-but, all-of, and any-of.

An event consists of a list of fields, provided as name/value pairs. A rule links these event fields to patterns that determine whether the event matches.

![example](./example.png)

# Quick Start

```go
import (
    hypermatch "github.com/SchwarzIT/hypermatch"
)

func main() {
    //Initialize hypermatch
    hm := hypermatch.NewHyperMatch()
    
    //Add a rule
    if err := hm.AddRule("markus_rule", hypermatch.ConditionSet{
        hypermatch.Condition{Path: "firstname", Pattern: hypermatch.Pattern{Type: hypermatch.PatternEquals, Value: "markus"}},
        hypermatch.Condition{Path: "lastname", Pattern: hypermatch.Pattern{Type: hypermatch.PatternEquals, Value: "troßbach"}},
        }); err != nil {
            panic(err)
    }
    
    //Test with match
    matchedRules := hm.Match([]hypermatch.Property{
        {Path: "firstname", Values: []string{"markus"}},
        {Path: "lastname", Values: []string{"troßbach"}},
    })
    log.Printf("Following rules matches: %v", matchedRules)
    
    //Test without match
    matchedRules = hm.Match([]hypermatch.Property{
        {Path: "firstname", Values: []string{"john"}},
        {Path: "lastname", Values: []string{"doe"}},
    })
    log.Printf("Following rules matches: %v", matchedRules)
}
```

# Documentation
## Example Event

An event is represented as a JSON object with various fields. Here’s a sample event:

```javascript
{
        "name": "Too many parallel requests on system xy",
        "severity": "critical",
        "status": "firing",
        "message": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.",
        "team": "awesome-team",
        "application": "webshop",
        "component": "backend-service",
        "tags": [
            "shop",
            "backend"
        ]   
}
```

**This example will be referenced throughout the documentation.**

## Matching Basics

Rules in Hypermatch are composed of conditions defined by the `ConditionSet` type.

- **Case-Insensitive Matching**: All value comparisons are case-insensitive.
- **Supported Types**: Currently, only strings and string arrays are supported.

Each condition includes:

- **Path**: The field in the event to match against.
- **Pattern**: The pattern used to match the value at the specified path.

Here’s an example rule that matches the event above:

```go
ConditionSet{
    {
        Path: "status",
        Pattern: Pattern{Type: PatternEquals, Value: "firing"},
    },
    {
        Path: "name",
        Pattern: Pattern{Type: PatternAnythingBut, Sub: []Pattern{
                {Type: PatternWildcard, Value: "TEST*"},
            },
        },
    },
    {
        Path: "severity",
        Pattern: Pattern{ Type: PatternAnyOf,
            Sub: []Pattern{
                {Type: PatternEquals, Value: "critical"},
                {Type: PatternEquals, Value: "warning"},
            },
        },
    },
    {
        Path: "tags",
        Pattern: Pattern{ Type: PatternAllOf,
            Sub: []Pattern{
                {Type: PatternEquals, Value: "shop"},
                {Type: PatternEquals, Value: "backend"},
            },
        },
    },
}
```

The rules and conditions are also expressible as JSON objects. The following JSON is the equivalent of the above Go notation for a `ConditionSet`:

```javascript
{
    "status": {
        "equals": "firing"
    },
    "name": {
        "anythingBut": [
            {"wildcard": "TEST*"}
        ]
    },
    "severity": {
        "anyOf": [
            {"equals": "critical"},
            {"equals": "warning"}
        ]
    },
    "tags": {
        "allOf": [
            {"equals": "shop"},
            {"equals": "backend"}
        ]
    }
}
```

**Note**: For simplicity, all examples in this documentation will be presented in JSON format.

## Matching syntax
### "equals" matching
The `equals` condition checks if an attribute of the event matches a specified value, case-insensitively.

```javascript
{
    "status": {
        "equals": "firing"
    }
}
```

If the attribute value is type of:

- **String**: Checks if the value is equal to "firing"
- **String array**: Checks if the array contains an element equal to "firing"

### "prefix" matching
The `prefix` condition checks if an attribute starts with a specified prefix, case-insensitively.

```javascript
{
    "status": {
        "prefix": "fir"
    }
}
```

If the attribute value is type of:

- **String**: Checks if the value begins with "fir"
- **String array**: Checks if the array contains an element that begins with "fir"

### "suffix" matching
The `suffix` condition checks if an attribute ends with a specified suffix, case-insensitively.

```javascript
{
    "status": {
        "suffix": "ing"
    }
}
```

If the attribute value is type of:

- **String**: Checks if the value ends with "ing"
- **String array**: Checks if the array contains an element that ends with "ing"

### "wildcard" matching
The `wildcard` condition uses wildcards to match the value of an attribute, ignoring case.

- Use * as a wildcard to match any number of characters (including none).
- You cannot place wildcards directly next to each other.

```javascript
{
    "name": {
        "wildcard": "*parallel requests*"
    }
}
```

If the attribute value is type of:

- **String**: Checks if the value matches the pattern \*parallel requests\*
- **String array**: Checks if any value in the array matches the pattern

### "anythingBut" matching
The `anythingBut` condition negates the match, triggering only if the specified condition is not met.

```javascript
{
    "status": {
        "anythingBut": [
            {"equals": "firing"}
        ]
    }
}
```

If the attribute value is type of:

- **String**: Checks if the value is anything other than "firing"
- **String array**: Checks if the array does *not* contain an element equal to "firing"

### "anyOf" matching
`anyOf` does correspond to a boolean "inclusive-or". It checks multiple conditions and matches if **any** of the conditions are true.

```javascript
{
    "status": {
        "anyOf": [
            {"equals": "firing"},
            {"equals": "resolved"}
        ]
    }
}
```

If the attribute value is type of:

- **String**: Checks if the value is either "firing" or "resolved"
- **String array**: Checks if the array contains an element equal to "firing" or "resolved" or both.

### "allOf" matching
`allOf` does correspond to a boolean "and". It checks multiple conditions and matches if **all** the conditions are true.

```javascript
{
    "tags": {
        "allOf": [
            {"equals": "shop"},
            {"equals": "backend"}
        ]
    }
}
```

If the attribute value is type of:

- **String**: This condition makes no sense, as it checks if the value is equal to "shop" and "backend"
- **String array**: Checks if the array contains both "shop" and "backend"


# Performance

**hypermatch** is designed to be blazing fast with very large numbers of rules.
Nevertheless, there are a few things to consider to get maximum performance:
- Shorten the number of fields inside the rules, the fewer conditions, the shorter is the path to find them out.
- Try to make the **paths** as diverse as possible in events and rules. The more heterogeneous fields, the higher the performance.
- Reduce the number of **anyOf** conditions wherever possible


hypermatch

A simple RabbitMQ abstraction layer for queue administration and publishing and consuming of messages.

# Jazz

Abstraction layer for quick and simple rabbitMQ connection, messaging and administration. Inspired by Jazz Jackrabbit and his eternal hatred towards slow turtles.

<p align="center">
    <img src="https://upload.wikimedia.org/wikipedia/en/b/b4/Jazz_Jackrabbit.jpg" alt="Jazz Jackrabbit">
</p>


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

```golang
import(
	"github.com/socifi/jazz"
)

var dsn = "amqp://guest:guest@localhost: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!

```golang
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:

```golang
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

<sub><sup>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](https://en.wikipedia.org/wiki/File:Jazz_Jackrabbit.jpg)</sup></sub>


jazz

Asynchronous task queue/job queue based on distributed message passing.

machinery

messagebus is a Go simple async message bus, perfect for using as event bus when doing event sourcing, CQRS, DDD.

🚌 message-bus
================
[![Build Status](https://travis-ci.org/vardius/message-bus.svg?branch=master)](https://travis-ci.org/vardius/message-bus)
[![Go Report Card](https://goreportcard.com/badge/github.com/vardius/message-bus)](https://goreportcard.com/report/github.com/vardius/message-bus)
[![codecov](https://codecov.io/gh/vardius/message-bus/branch/master/graph/badge.svg)](https://codecov.io/gh/vardius/message-bus)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fvardius%2Fmessage-bus.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fvardius%2Fmessage-bus?ref=badge_shield)
[![](https://godoc.org/github.com/vardius/message-bus?status.svg)](https://pkg.go.dev/github.com/vardius/message-bus)
[![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/vardius/message-bus/blob/master/LICENSE.md)

<img align="right" height="180px" src="website/src/static/img/logo.png" alt="logo" />

Go simple async message bus.

📖 ABOUT
==================================================
Contributors:

* [Rafał Lorenz](http://rafallorenz.com)

Want to contribute ? Feel free to send pull requests!

Have problems, bugs, feature ideas?
We are using the github [issue tracker](https://github.com/vardius/message-bus/issues) to manage them.

## 📚 Documentation

For **documentation** (_including examples_), **visit [rafallorenz.com/message-bus](http://rafallorenz.com/message-bus)**

For **GoDoc** reference, **visit [pkg.go.dev](https://pkg.go.dev/github.com/vardius/message-bus)**

🚏 HOW TO USE
==================================================

## 🚅 Benchmark

```bash
➜  message-bus git:(master) ✗ go test -bench=. -cpu=4 -benchmem
goos: darwin
goarch: amd64
pkg: github.com/vardius/message-bus
BenchmarkPublish-4                   	 4430224	       250 ns/op	       0 B/op	       0 allocs/op
BenchmarkSubscribe-4                 	  598240	      2037 ns/op	     735 B/op	       5 allocs/op
```

👉 **[Click here](https://rafallorenz.com/message-bus/docs/benchmark)** to see all benchmark results.

## Features
- [Documentation](https://rafallorenz.com/message-bus/)

🚏 HOW TO USE
==================================================

- [Basic example](https://rafallorenz.com/message-bus/docs/basic-example)
- [Pub/Sub](https://rafallorenz.com/message-bus/docs/pubsub)

📜 [License](LICENSE.md)
-------

This package is released under the MIT license. See the complete license in the package:

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fvardius%2Fmessage-bus.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fvardius%2Fmessage-bus?ref=badge_large)


messagebus

[![PkgGoDev](https://pkg.go.dev/badge/github.com/cskr/pubsub/v2)](https://pkg.go.dev/github.com/cskr/pubsub/v2)

Package pubsub implements a simple multi-topic pub-sub library. 

Install pubsub with,

    go get github.com/cskr/pubsub/v2

Use of this module is governed by a BSD-style license that can be found in the
[LICENSE](LICENSE) file.


pubsub

rabtap

RapidMQ is a lightweight and reliable library for managing of the local messages queue.

RapidMQ

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.

[![Build Status](https://travis-ci.org/sbabiv/rmqconn.svg?branch=master)](https://travis-ci.org/sbabiv/rmqconn)
[![Coverage Status](https://coveralls.io/repos/github/sbabiv/rmqconn/badge.svg?branch=master)](https://coveralls.io/github/sbabiv/rmqconn?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/sbabiv/rmqconn)](https://goreportcard.com/report/github.com/sbabiv/rmqconn)
[![GoDoc](https://godoc.org/github.com/sbabiv/rmqconn?status.svg)](https://godoc.org/github.com/sbabiv/rmqconn)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#messaging)

# rmqconn
RabbitMQ Reconnection for Golang    

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

Use the default method `func Dial (url string) (Conner, error)` to connect to the server.
You can implement your connection function and pass it to `rmqconn.Open("", customFunc)`

## Getting started

#### 1. install

``` sh
go get -u github.com/sbabiv/rmqconn
```

#### 2. use it

```Go
conn, err := rmqconn.Open("amqp://usr:pwd@host:5672", rmqconn.Dial)
defer conn.Close()

if err != nil {
    return
}

if conn.IsConnected() {
    ch, err := conn.GetChannel()
    if err != nil {
        return
    }
    defer ch.Close()

    err = ch.Publish("", "queueName", false, false, amqp.Publishing{
        Body: []byte("hello wolrd"),
    })
}
  ```
## Licence
[MIT](https://opensource.org/licenses/MIT)

## Author 
Babiv Sergey


rmqconn

# sarama

[![Go Reference](https://pkg.go.dev/badge/github.com/IBM/sarama.svg)](https://pkg.go.dev/github.com/IBM/sarama)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/IBM/sarama/badge?style=flat)](https://securityscorecards.dev/viewer/?uri=github.com/IBM/sarama)
[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7996/badge)](https://www.bestpractices.dev/projects/7996)

Sarama is an MIT-licensed Go client library for [Apache Kafka](https://kafka.apache.org/).

## Getting started

- API documentation and examples are available via [pkg.go.dev](https://pkg.go.dev/github.com/IBM/sarama).
- Mocks for testing are available in the [mocks](./mocks) subpackage.
- The [examples](./examples) directory contains more elaborate example applications.
- The [tools](./tools) directory contains command line tools that can be useful for testing, diagnostics, and instrumentation.

You might also want to look at the [Frequently Asked Questions](https://github.com/IBM/sarama/wiki/Frequently-Asked-Questions).

## Compatibility and API stability

Sarama provides a "2 releases + 2 months" compatibility guarantee: we support
the two latest stable releases of Kafka and Go, and we provide a two month
grace period for older releases. However, older releases of Kafka are still likely to work.

Sarama follows semantic versioning and provides API stability via the standard Go
[module version numbering](https://go.dev/doc/modules/version-numbers) scheme.

A changelog is available [here](CHANGELOG.md).

## Contributing

- Get started by checking our [contribution guidelines](https://github.com/IBM/sarama/blob/main/CONTRIBUTING.md).
- Read the [Sarama wiki](https://github.com/IBM/sarama/wiki) for more technical and design details.
- The [Kafka Protocol Specification](https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol) contains a wealth of useful information.
- For more general issues, there is [a google group](https://groups.google.com/forum/#!forum/kafka-clients) for Kafka client developers.
- If you have any questions, just ask!


The Best Go Libraries For Messaging - Libraries that implement messaging systems. (31)

ami