add rmb client in go

Author: rawdaGastan

rmb-sdk-go/Makefile

@@ -0,0 +1,29 @@
+PWD := $(shell pwd)
+GOPATH := $(shell go env GOPATH)
+
+all: verifiers test
+
+test: 
+	@echo "Running Tests"
+	go test -v ./...
+
+coverage: clean 
+	@echo "Installing gopherbadger" && go get -u github.com/jpoles1/gopherbadger && go install github.com/jpoles1/gopherbadger
+	mkdir coverage
+	go test -v -vet=off ./... -coverprofile=coverage/coverage.out
+	go tool cover -html=coverage/coverage.out -o coverage/coverage.html
+	@${GOPATH}/bin/gopherbadger -png=false -md="README.md"
+	rm coverage.out
+	go mod tidy
+
+clean:
+	rm ./coverage -rf
+	rm ./bin -rf
+
+getverifiers:
+	@echo "Installing golangci-lint" && go install github.com/golangci/golangci-lint/cmd/golangci-lint
+	go mod tidy
+
+lint:
+	@echo "Running $@"
+	golangci-lint run -c ../.golangci.yml

rmb-sdk-go/README.md

@@ -0,0 +1,55 @@
+[![Go Documentation](https://godocs.io/github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go?status.svg)](https://godocs.io/github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go)
+
+# Introduction
+
+This is a `GO` sdk that can be used to build both **services**, and **clients**
+that can talk over the `rmb`.
+
+[RMB](https://github.com/threefoldtech/rmb-rs) is a message bus that enable secure
+and reliable `RPC` calls across the globe.
+
+`RMB` itself does not implement an RPC protocol, but just the secure and reliable messaging
+hence it's up to server and client to implement their own data format.
+
+## How it works
+
+If two processes needed to communicate over `RMB`, they both need to have some sort of a connection to an `rmb-relay`.\
+This connection could be established using a `direct-client`, or an `rmb-peer`.
+
+### Direct client
+
+A process could connect to an `rmb-relay` using a direct client.\
+To create a new direct client instance, a process needs to have:
+
+- A valid mnemonics, with an activated account on the TFChain.
+- The key type of these mnemonics.
+- A relay URL that the direct client will connect to.
+- A session id. This could be anything, but a twin must only have a unique session id per connection.
+- A substrate connection.
+
+#### **Example**
+
+Creating a new direct client instance:
+
+```Go
+subManager := substrate.NewManager("wss://tfchain.dev.grid.tf/ws")
+sub, err := subManager.Substrate()
+if err != nil {
+    return fmt.Errorf("failed to connect to substrate: %w", err)
+}
+
+defer sub.Close()
+client, err := direct.NewRpcClient(direct.KeyTypeSr25519, mnemonics, "wss://relay.dev.grid.tf", "test-client", sub, false)
+if err != nil {
+    return fmt.Errorf("failed to create direct client: %w", err)
+}
+```
+
+Assuming there is a remote calculator process that could add two integers, an rmb call using the direct client would look like this:
+
+```Go
+x := 1
+y := 2
+var sum int
+err := client.Call(ctx, destinationTwinID, "calculator.add", []int{x, y}, &sum)
+```

rmb-sdk-go/client.go

@@ -0,0 +1,174 @@
+package rmb
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/gomodule/redigo/redis"
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+)
+
+const (
+	DefaultSchema = "application/json"
+
+	systemLocalBus = "msgbus.system.local"
+
+	// DefaultAddress default redis address when no address is passed
+	DefaultAddress = "tcp://127.0.0.1:6379"
+)
+
+type redisClient struct {
+	pool *redis.Pool
+}
+
+// Default return instance of to default (local) rmb
+// shortcut for NewClient(DefaultAddress)
+func Default() (Client, error) {
+	return NewRMBClient(DefaultAddress)
+}
+
+// NewRMBClient creates a new rmb client that runs behind an rmb-peer. This
+// client does not talk to the rmb relay directly, instead talk to an rmb-peer
+// instance (like a gateway) that itself maintains a connection to the relay.
+// the rmb-peer does all the heavy lifting, including signing, encryption,
+// validation of the response, etc...
+//
+// hence the address in this case, is an address to the local redis that must
+// be the same one used with the rmb-peer process.
+//
+// for more details about rmb-peer please check https://github.com/threefoldtech/rmb-rs
+// Since the rmb protocol does not specify a "payload" format this Client and the DefaultRouter
+// both uses json to encode and decode the rpc body. Hence this client should be always
+// 100% compatible with services built with the DefaultRouter.
+func NewRMBClient(address string, poolSize ...uint32) (Client, error) {
+
+	if len(address) == 0 {
+		address = DefaultAddress
+	}
+
+	pool, err := NewRedisPool(address, poolSize...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &redisClient{
+		pool: pool,
+	}, nil
+}
+
+// Close closes the rmb client
+func (c *redisClient) Close() error {
+	return c.pool.Close()
+}
+
+// Call calls the twin with given function and message. Can return a RemoteError if error originated by remote peer
+// in that case it should also include extra Code
+func (c *redisClient) Call(ctx context.Context, twin uint32, fn string, data interface{}, result interface{}) error {
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return errors.Wrap(err, "failed to serialize request data")
+	}
+
+	var ttl uint64 = 5 * 60
+	deadline, ok := ctx.Deadline()
+	if ok {
+		ttl = uint64(time.Until(deadline).Seconds())
+	}
+
+	queue := uuid.NewString()
+	msg := Request{
+		Version:    1,
+		Expiration: int(ttl),
+		Command:    fn,
+		TwinDest:   []uint32{twin},
+		Data:       base64.StdEncoding.EncodeToString(bytes),
+		Schema:     DefaultSchema,
+		RetQueue:   queue,
+	}
+
+	bytes, err = json.Marshal(msg)
+	if err != nil {
+		return errors.Wrap(err, "failed to serialize message")
+	}
+	con := c.pool.Get()
+	defer con.Close()
+
+	_, err = con.Do("RPUSH", systemLocalBus, bytes)
+	if err != nil {
+		return errors.Wrap(err, "failed to push message to local twin")
+	}
+
+	// now wait for response.
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+
+		slice, err := redis.ByteSlices(con.Do("BLPOP", queue, 5))
+		if err != nil && err != redis.ErrNil {
+			return errors.Wrap(err, "unexpected error during waiting for the response")
+		}
+
+		if err == redis.ErrNil || slice == nil {
+			//timeout, just try again immediately
+			continue
+		}
+
+		// found a response
+		bytes = slice[1]
+		break
+	}
+
+	var ret IncomingResponse
+
+	// we have a response, so load or fail
+	if err := json.Unmarshal(bytes, &ret); err != nil {
+		return errors.Wrap(err, "failed to load response message")
+	}
+	// errorred ?
+	if ret.Error != nil {
+		return RemoteError{
+			Code:    ret.Error.Code,
+			Message: ret.Error.Message,
+		}
+	}
+
+	// not expecting a result
+	if result == nil {
+		return nil
+	}
+
+	if ret.Schema != DefaultSchema {
+		return fmt.Errorf("received invalid schema '%s' was expecting %s", ret.Schema, DefaultSchema)
+	}
+
+	if len(ret.Data) == 0 {
+		return fmt.Errorf("no response body was returned")
+	}
+
+	bytes, err = base64.StdEncoding.DecodeString(ret.Data)
+	if err != nil {
+		return errors.Wrap(err, "invalid data body encoding")
+	}
+
+	if err := json.Unmarshal(bytes, result); err != nil {
+		return errors.Wrap(err, "failed to decode response body")
+	}
+
+	return nil
+}
+
+type RemoteError struct {
+	Code    uint32
+	Message string
+}
+
+func (e RemoteError) Error() string {
+	return e.Message
+}

rmb-sdk-go/examples/client/README.md

@@ -0,0 +1,15 @@
+# Introduction
+
+This is a `Go` example for the `RMB` [default local client](https://github.com/threefoldtech/tfgrid-sdk-go/blob/development/rmb-sdk-go/client.go) that is used send `RMB` messages.
+
+## How it works
+
+To use the example, you needs to:
+
+-   A twinId of a remote calculator process that could add two integers
+
+## Usage
+
+Make sure to have a remote process that the client can call with valid twinId.
+
+Run the client and wait for the response.

rmb-sdk-go/examples/client/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go"
+)
+
+func app() error {
+
+	client, err := rmb.Default()
+
+	if err != nil {
+		return err
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	const dst = 7 // <- replace this with the twin id of where the service is running
+	// it's okay to run both the server and the client behind the same rmb-peer
+	var output float64
+	if err := client.Call(ctx, dst, "calculator.add", []float64{10, 20}, &output); err != nil {
+		return err
+	}
+
+	fmt.Printf("output: %f\n", output)
+
+	return nil
+}
+
+func main() {
+	if err := app(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

rmb-sdk-go/examples/rpc_client/README.md

@@ -0,0 +1,16 @@
+# Introduction
+
+This is a `Go` example for the `RMB` [rpc client](https://github.com/threefoldtech/tfgrid-sdk-go/blob/development/rmb-sdk-go/peer/rpc.go) that can send `RMB` messages through working with zos peer
+
+## How it works
+
+To use the example, you needs to:
+
+-   Set the mnemonics variable to a valid mnemonics, with an activated account on the TFChain.
+-   A node id to send the call to
+
+## Usage
+
+Make sure to use a valid node id that the client can call with valid twinId.
+
+Run the client and wait for the response.

rmb-sdk-go/examples/rpc_client/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	substrate "github.com/threefoldtech/tfchain/clients/tfchain-client-go"
+	"github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer"
+)
+
+type version struct {
+	ZOS   string `json:"zos"`
+	ZInit string `json:"zinit"`
+}
+
+func app() error {
+	mnemonics := "<mnemonics goes here>"
+	subNodeURL := "wss://tfchain.dev.grid.tf/ws"
+	relayURL := "wss://relay.dev.grid.tf"
+
+	subManager := substrate.NewManager(subNodeURL)
+
+	client, err := peer.NewRpcClient(context.Background(), mnemonics, subManager, peer.WithRelay(relayURL), peer.WithSession("test-client"))
+	if err != nil {
+		return fmt.Errorf("failed to create direct client: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	const dstTwin uint32 = 11 // <- replace this with any node i
+	var ver version
+	if err := client.Call(ctx, dstTwin, "zos.system.version", nil, &ver); err != nil {
+		return err
+	}
+
+	fmt.Printf("output: %s\n", ver)
+	return nil
+}
+
+func main() {
+	if err := app(); err != nil {
+		log.Fatal(err)
+	}
+}