a

.github/workflows/tests.yaml

@@ -0,0 +1,98 @@
+name: Tests
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  deps:
+    name: Dependencies
+    runs-on: ubuntu-latest
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: '1.15'
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Restore cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-
+    - name: Download dependencies
+      run: go mod download
+  unit-test:
+    name: Unit Test
+    runs-on: ubuntu-latest
+    needs: deps
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: '1.13'
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Restore cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-
+    - name: Setup dependencies
+      env:
+        GO111MODULE: off
+      run: make setup-ci
+    - name: Run tests
+      run: make test-coverage
+    - name: Send coverage
+      env:
+        COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: ~/go/bin/goveralls -coverprofile=coverprofile.out -service=github
+  e2e-test-nats:
+    name: Nats Test End to End
+    runs-on: ubuntu-latest
+    needs: deps
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: '1.13'
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Restore cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-
+    - name: Run tests
+      run: make e2e-test-nats
+  e2e-test-grpc:
+    name: GRPC Test End to End
+    runs-on: ubuntu-latest
+    needs: deps
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: '1.13'
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Restore cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-
+    - name: Run tests
+      run: make e2e-test-grpc

Makefile

@@ -50,6 +50,9 @@ run-custom-metrics-example:
 run-rate-limiting-example:
 	@go run examples/demo/rate_limiting/main.go
 
+protos-compile-demo:
+	@protoc -I examples/demo/protos examples/demo/protos/*.proto --go_out=.
+
 protos-compile:
 	@cd benchmark/testdata && ./gen_proto.sh
 	@protoc -I pitaya-protos/ pitaya-protos/*.proto --go_out=plugins=grpc:protos

README.md

@@ -1,13 +1,17 @@
 # pitaya [![Build Status][7]][8] [![Coverage Status][9]][10] [![GoDoc][1]][2] [![Docs][11]][12] [![Go Report Card][3]][4] [![MIT licensed][5]][6]
 
+*WARNING*: This version has entered the deprecation flow described [here](https://github.com/topfreegames/pitaya/issues/240), we strongly recommend to use the new version of Pitaya v2.x found in the [main branch](https://github.com/topfreegames/pitaya/tree/main).
+
+---
+
 [1]: https://godoc.org/github.com/topfreegames/pitaya?status.svg
 [2]: https://godoc.org/github.com/topfreegames/pitaya
 [3]: https://goreportcard.com/badge/github.com/topfreegames/pitaya
 [4]: https://goreportcard.com/report/github.com/topfreegames/pitaya
 [5]: https://img.shields.io/badge/license-MIT-blue.svg
 [6]: LICENSE
-[7]: https://travis-ci.org/topfreegames/pitaya.svg?branch=master
-[8]: https://travis-ci.org/topfreegames/pitaya
+[7]: https://github.com/topfreegames/pitaya/actions/workflows/tests.yaml/badge.svg
+[8]: https://github.com/topfreegames/pitaya/actions/workflows/tests.yaml
 [9]: https://coveralls.io/repos/github/topfreegames/pitaya/badge.svg?branch=master
 [10]: https://coveralls.io/github/topfreegames/pitaya?branch=master
 [11]: https://readthedocs.org/projects/pitaya/badge/?version=latest
@@ -41,7 +45,7 @@ Here's one example of running Pitaya:
 
 Start etcd (This command requires docker-compose and will run an etcd container locally. An etcd may be run without docker if prefered.)
 ```
-cd ./examples/testing && docker-compose up -d etcd
+docker-compose -f examples/testing/docker-compose.yml up -d etcd
 ```
 run the connector frontend server from cluster_grpc example
 ```

acceptor/tcp_acceptor.go

@@ -138,6 +138,9 @@ func (a *TCPAcceptor) ListenAndServeTLS(cert, key string) {
 	tlsCfg := &tls.Config{Certificates: []tls.Certificate{crt}}
 
 	listener, err := tls.Listen("tcp", a.addr, tlsCfg)
+	if err != nil {
+		logger.Log.Fatalf("Failed to listen: %s", err.Error())
+	}
 	a.listener = listener
 	a.running = true
 	a.serve()

app_test.go

@@ -30,7 +30,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/coreos/etcd/integration"
+	"go.etcd.io/etcd/integration"
 	"github.com/google/uuid"
 	opentracing "github.com/opentracing/opentracing-go"
 	"github.com/sirupsen/logrus"

client/protoclient.go

@@ -26,6 +26,7 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"strings"
 	"time"
@@ -144,6 +145,11 @@ func getOutputInputNames(command map[string]interface{}) (string, string, error)
 
 	out := command["output"]
 	outputDocsArr := out.([]interface{})
+	// we can have handlers that have no return specified.
+	if len(outputDocsArr) == 0 {
+		return inputName, "", nil
+	}
+
 	outputDocs, ok := outputDocsArr[0].(map[string]interface{})
 	if ok {
 		for k := range outputDocs {
@@ -211,7 +217,7 @@ func (pc *ProtoClient) getDescriptors(data string) error {
 		cmdInfo := v.(map[string]interface{})
 		in, out, err := getOutputInputNames(cmdInfo)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to get output and input names for '%s' handler: %w", k, err)
 		}
 
 		var command Command
@@ -250,33 +256,33 @@ func (pc *ProtoClient) getDescriptors(data string) error {
 
 	encodedNames, err := proto.Marshal(protname)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to encode proto names: %w", err)
 	}
 	_, err = pc.SendRequest(pc.descriptorsRoute, encodedNames)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to send proto descriptors request: %w", err)
 	}
 
 	response := <-pc.Client.IncomingMsgChan
 	descriptors := &protos.ProtoDescriptors{}
 	if err := proto.Unmarshal(response.Data, descriptors); err != nil {
-		return err
+		return fmt.Errorf("failed to unmarshal proto descriptors response: %w", err)
 	}
 
 	// get all proto types
 	descriptorArray := make([]*protobuf.FileDescriptorProto, 0)
 	for i := range descriptors.Desc {
 		fileDescriptorProto, err := unpackDescriptor(descriptors.Desc[i])
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to unpack descriptor: %w", err)
 		}
 
 		descriptorArray = append(descriptorArray, fileDescriptorProto)
 		pc.descriptorsNames[names[i]] = true
 	}
 
 	if err = pc.buildProtosFromDescriptor(descriptorArray); err != nil {
-		return err
+		return fmt.Errorf("failed to build proto from descriptor: %w", err)
 	}
 
 	return nil
@@ -341,11 +347,11 @@ func (pc *ProtoClient) LoadServerInfo(addr string) error {
 
 	docs := &protos.Doc{}
 	if err := proto.Unmarshal(response.Data, docs); err != nil {
-		return err
+		return fmt.Errorf("failed to unmarshal docs route response: %w", err)
 	}
 
 	if err := pc.getDescriptors(docs.Doc); err != nil {
-		return err
+		return fmt.Errorf("failed to read proto descriptors: %w", err)
 	}
 
 	pc.Disconnect()
@@ -369,7 +375,6 @@ func (pc *ProtoClient) waitForData() {
 	for {
 		select {
 		case response := <-pc.Client.IncomingMsgChan:
-
 			inputMsg := dynamic.NewMessage(pc.expectedInputDescriptor)
 
 			msg, ok := pc.info.Commands[response.Route]
@@ -388,27 +393,27 @@ func (pc *ProtoClient) waitForData() {
 				}
 				response.Data, err = json.Marshal(errMsg)
 				if err != nil {
-					logger.Log.Errorf("Erro encode error to json: %s", string(response.Data))
+					logger.Log.Errorf("error encode error to json: %s", string(response.Data))
 					continue
 				}
 				pc.IncomingMsgChan <- response
 				continue
 			}
 
 			if inputMsg == nil {
-				logger.Log.Errorf("Not expected data: %s", string(response.Data))
+				logger.Log.Errorf("not expected data: %s", string(response.Data))
 				continue
 			}
 
 			err := inputMsg.Unmarshal(response.Data)
 			if err != nil {
-				logger.Log.Errorf("Erro decode data: %s", string(response.Data))
+				logger.Log.Errorf("error decode data: %s", string(response.Data))
 				continue
 			}
 
 			data, err2 := inputMsg.MarshalJSON()
 			if err2 != nil {
-				logger.Log.Errorf("Erro encode data to json: %s", string(response.Data))
+				logger.Log.Errorf("error encode data to json: %s", string(response.Data))
 				continue
 			}