>>> import hmac
>>> from hashlib import sha256

>>> h = hmac.new(b"secret", digestmod=sha256)
>>> h.update("42".encode())
>>> h.hexdigest()
'93c121e7aa437a1e01e3c512c6f0ce3c821a839025dca4408f85616de4aaee70'

{"id": 1, "method": "subscribe", "params": {"channel": "ch1"}}
{"id": 2, "method": "subscribe", "params": {"channel": "ch2"}}

0a 0a 32 08 08 07 10 00 18 1a 20 00 0a 08 22 06 08 02 10 19 18 03 
0a 09 22 07 08 02 10 a2 03 18 20 0a 09 22 07 08 02 10 8d 02 ...

BenchmarkJsonMarshal-8            500000    2980 ns/op    1223 B/op   9 allocs/op
BenchmarkJsonUnmarshal-8          500000    3120 ns/op    463 B/op    7 allocs/op


BenchmarkProtobufMarshal-8        2000000    901 ns/op    200 B/op    7 allocs/op
BenchmarkProtobufUnmarshal-8      2000000    692 ns/op    192 B/op   10 allocs/op

JSON: {"type":"ping","time":123456789} = 32 bytes

Protobuf: 0A 05 08 95 9A EF 3A = 7 bytes

service Centrifuge {
    rpc Communicate(stream Command) returns (stream Reply) {}
}

message Command {
    uint32 id = 1;
    uint32 method = 2;
    bytes params = 3;
}

message Reply {
    uint32 id = 1;
    Error error = 2;
    bytes result = 3;
}

server {
    listen 443 ssl http2;

    ssl_certificate     cert.pem;
    ssl_certificate_key key.pem;

    proxy_buffering off;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Scheme $scheme;
    proxy_set_header Host $http_host;

    location /proto.Centrifuge {
        grpc_pass grpc://localhost:8001;
    }

    location /connection/websocket {
        proxy_pass http://localhost:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
    }
}

func authMiddleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
        credentials := &centrifuge.Credentials{
	    UserID: "42",
	    Exp:    time.Now().Unix() + 600,
	    Info:   []byte(`{"name": "Alexander"}`),
	}
	ctx = context.WithValue(
            ctx, 
            centrifuge.CredentialsContextKey,
            credentials,
        )
	r = r.WithContext(ctx)
	h.ServeHTTP(w, r)
    })
}

authInterceptor := func(
    srv interface{}, 
    ss grpc.ServerStream, 
    info *grpc.StreamServerInfo, 
    handler grpc.StreamHandler
) error {
	ctx := ss.Context()
	newCtx := context.WithValue(
            ctx, 
            centrifuge.CredentialsContextKey, 
            &centrifuge.Credentials{
		UserID: "42",
		Exp:    time.Now().Unix() + 10,
		Info:   []byte(`{"name": "Alexander"}`),
	    },
        )
	wrapped := grpc_middleware.WrapServerStream(ss)
	wrapped.WrappedContext = newCtx
	return handler(srv, wrapped)
}

var centrifuge = new Centrifuge("ws://example.com/websocket");

centrifuge.subscribe("channel", function(message){
    console.log(message);
});

centrifuge.connect();

var centrifuge = new Centrifuge("ws://example.com/websocket");

centrifuge.on("connect", function(){
    centrifuge.send({"text": "hello"});
});

centrifuge.on("message", function(data) {
    console.log(data);
});

centrifuge.connect();

var centrifuge = new Centrifuge("ws://example.com/websocket");

centrifuge.rpc({"method": "say_hi"}).then(function(data){
    console.log(data);
});

centrifuge.connect();

> XADD mystream * payload "hello"
1506871964177.0


> XRANGE mystream 1506871964175.0 +
1) 1) 1506871964177.0
   2) 1) "payload"
      2) "hello"



> XREAD BLOCK 5000 STREAMS mystream $