Merge pull request #50 from OlgaMinyaeva/master

Mongo v.4 storage implementaton

Author: Andrei Skomorkhov

.travis.yml

@@ -10,6 +10,7 @@ after_success:
   - bash <(curl -s https://codecov.io/bash)
 services:
   - mysql
+  - mongodb
 
 env:
-  - TEST_MYSQL_CONNECTION="root:@(127.0.0.1:3306)/%dbname%?tx_isolation=SERIALIZABLE&parseTime=true"
+  - TEST_MYSQL_CONNECTION="root:@(127.0.0.1:3306)/%dbname%?tx_isolation=SERIALIZABLE&parseTime=true";TEST_MONGO_CONNECTION="mongodb://localhost:27017"

README.md

@@ -60,17 +60,18 @@ Configurations are stored in json files. Example:
 | logger.level  | `debug`, `info`, `warning`, `error` | Logging level.         |
 
 ### DB - Configuration of storage.
-| Option            | Possible values  | Description                                |
-| ----------------- | ---------------  | ------------------------------------------ |
-| db.implementation | `mysql`, `local` | Select your favorite db, or local storage. |
-| db.connection     | see next table   | DSN for your db.                           |
+| Option            | Possible values          | Description                                |
+| ----------------- | ------------------------ | ------------------------------------------ |
+| db.implementation | `mysql`, `local`, `mongo`| Select your favorite db, or local storage. |
+| db.connection     | see next table           | DSN for your db.                           |
 
 >Note: Note: Local (in-memory) storage does not support common session storage between grid-instances.
 
 | DB implementation | DSN format                                                                                                                                                              |
 | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | mysql             | [spec](https://github.com/go-sql-driver/mysql#dsn-data-source-name), example `db_user:db_pass@(db_host:3306)/db_name?parseTime=true` (parseTime=true - required option) |
 | local             | omit this property, because every instance have its own in-memory storage                                                                                               |
+| mongo             | NOTE! Mongo db supports only persistent node strateg and version from 4.0, example `mongodb://localhost:27017`
 
 ### Statsd - Configuration of metrics(optional).
 | Option          | Possible values | Description            |

config/config.go

@@ -53,6 +53,7 @@ type Logger struct {
 type DB struct {
 	Implementation string `json:"implementation"`
 	Connection     string `json:"connection"`
+	DbName         string `json:"db_name"`
 }
 
 // Statsd - Settings of metrics sender.

handlers/createSession.go

@@ -74,7 +74,7 @@ func (h *CreateSession) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 func (h *CreateSession) tryCreateSession(r *http.Request, capabilities *capabilities.Capabilities) (*proxy.ResponseWriter, error) {
 	select {
 	case <-r.Context().Done():
-		err := errors.New("Request cancelled by client, " + r.Context().Err().Error())
+		err := errors.New("Request canceled by client, " + r.Context().Err().Error())
 		return nil, err
 	default:
 	}

invoke.go

@@ -3,6 +3,8 @@ package main
 import (
 	_ "github.com/go-sql-driver/mysql"
 
+	"github.com/qa-dev/jsonwire-grid/storage/mongo"
+
 	"github.com/qa-dev/jsonwire-grid/config"
 
 	"errors"
@@ -32,6 +34,13 @@ func invokeStorageFactory(config config.Config) (factory StorageFactoryInterface
 		factory = new(mysql.Factory)
 	case "local":
 		factory = new(local.Factory)
+	case "mongo":
+		for _, s := range config.Grid.StrategyList {
+			if s.Type != string(pool.NodeTypePersistent) {
+				err = errors.New("Invalid config: Mongo db supports only persistent node strategy ")
+			}
+		}
+		factory = new(mongo.Factory)
 	default:
 		err = errors.New("Invalid config, unknown param [db.implementation=" + config.DB.Implementation + "]")
 	}

pool/node.go

@@ -22,14 +22,14 @@ type Node struct {
 	// The value may depend on the strategy:
 	// - for constant nodes ip: port
 	// - for temporary pod.name
-	Key              string                      `json:"key"`
-	Type             NodeType                    `json:"type"`
-	Address          string                      `json:"address"`
-	Status           NodeStatus                  `json:"status"`
-	SessionID        string                      `json:"session_id"`
-	Updated          int64                       `json:"updated"`
-	Registered       int64                       `json:"registered"`
-	CapabilitiesList []capabilities.Capabilities `json:"capabilities_list"`
+	Key              string                      `json:"key" bson:"key"`
+	Type             NodeType                    `json:"type" bson:"type"`
+	Address          string                      `json:"address" bson:"address"`
+	Status           NodeStatus                  `json:"status" bson:"status"`
+	SessionID        string                      `json:"session_id" bson:"session_id"`
+	Updated          int64                       `json:"updated" bson:"updated"`
+	Registered       int64                       `json:"registered" bson:"registered"`
+	CapabilitiesList []capabilities.Capabilities `json:"capabilities_list" bson:"capabilities_list"`
 }
 
 func (n *Node) String() string {

pool/strategy/kubernetes/strategy.go

@@ -48,7 +48,6 @@ func (s *Strategy) Reserve(desiredCaps capabilities.Capabilities) (pool.Node, er
 	}
 	node.Address = nodeAddress
 	return *node, nil
-
 }
 
 func (s *Strategy) CleanUp(node pool.Node) error {

pool/strategy/persistent/strategy.go

@@ -112,7 +112,6 @@ func (s *Strategy) registerCapabilities(nodeList []pool.Node) {
 	for _, node := range nodeList {
 		for _, availableCaps := range node.CapabilitiesList {
 			s.capsComparator.Register(availableCaps)
-
 		}
 	}
 }

storage/mongo/factory.go

@@ -0,0 +1,78 @@
+package mongo
+
+import (
+	"context"
+	"errors"
+	"strconv"
+	"strings"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"go.mongodb.org/mongo-driver/x/bsonx"
+
+	"github.com/qa-dev/jsonwire-grid/config"
+	"github.com/qa-dev/jsonwire-grid/pool"
+)
+
+type Factory struct {
+}
+
+func (f *Factory) Create(cfg config.Config) (pool.StorageInterface, error) {
+	ctx := context.Background()
+	client, err := mongo.Connect(ctx, options.Client().ApplyURI(cfg.DB.Connection))
+	if err != nil {
+		panic("Database connection error: " + err.Error())
+	}
+
+	err = client.Ping(ctx, nil)
+	if err != nil {
+		err = errors.New("Database connection not established: " + err.Error())
+		return nil, err
+	}
+
+	db := client.Database(cfg.DB.DbName)
+	err = checkServerVersion(ctx, client)
+	if err != nil {
+		err = errors.New("version check error: " + err.Error())
+		return nil, err
+	}
+
+	s := NewMongoStorage(db)
+	mod := mongo.IndexModel{
+		Keys: bson.M{
+			"key":     1,
+			"address": 1,
+		},
+		Options: options.Index().SetUnique(true).SetName("key_address_unique"),
+	}
+
+	_, err = s.collection.Indexes().CreateOne(ctx, mod)
+	if err != nil {
+		err = errors.New("Create index error: " + err.Error())
+		return nil, err
+	}
+
+	return s, nil
+}
+
+func checkServerVersion(ctx context.Context, client *mongo.Client) error {
+	serverStatus, err := client.Database("admin").RunCommand(
+		ctx,
+		bsonx.Doc{bsonx.Elem{Key: "serverStatus", Value: bsonx.Int32(1)}},
+	).DecodeBytes()
+	if err != nil {
+		return err
+	}
+
+	version, err := serverStatus.LookupErr("version")
+	if err != nil {
+		return err
+	}
+
+	majorVersion, _ := strconv.Atoi(strings.Split(version.StringValue(), ".")[0])
+	if majorVersion < 4 {
+		return errors.New("mongodb version not supported: " + version.StringValue())
+	}
+	return nil
+}

storage/mongo/factory_test.go

@@ -0,0 +1,22 @@
+package mongo
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/qa-dev/jsonwire-grid/config"
+)
+
+func TestFactory_Create_Positive(t *testing.T) {
+	f := Factory{}
+	storage, err := f.Create(config.Config{
+		DB: config.DB{
+			Connection: os.Getenv(dbConnectionStringEnvVariable),
+			DbName:     "grid",
+		},
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, storage)
+}