Merge pull request #4 from qa-dev/strategies

strategies

Author: andrskom

.gitignore

@@ -23,6 +23,6 @@
 
 # Your local config
 config.json
-bindata.go
+/bindata.go
 dist/
 dbconfig.yml

config-sample.json

@@ -7,11 +7,46 @@
       "connection": "root:@(localhost:3306)/grid?tx_isolation=SERIALIZABLE&parseTime=true&interpolateParams=true"
   },
   "grid": {
+    "client_type": "selenium",
     "port": 4444,
     "strategy_list": [
       {
-        "type": "default",
-        "limit": 0
+        "type": "persistent"
+      },
+      {
+        "type": "kubernetes",
+        "limit": 20,
+        "params": {},
+        "node_list": [
+          {
+            "params": {
+              "image":"myimage:latest",
+              "port": "5555"
+            },
+            "capabilities_list": [
+              {
+                "browserName": "firefox",
+                "browserVersion": 50
+              },
+              {
+                "browserName": "chrome",
+                "browserVersion": 150
+              }
+            ]
+          },
+          {
+            "params": {
+              "image":"myimage2:latest",
+              "port": "5555"
+            },
+            "capabilities_list": [
+              {
+                "browserName": "firefox",
+                "browserVersion": 54
+              }
+            ]
+          }
+        ]
       }
     ],
     "busy_node_duration": "15m",

config-test.json

@@ -7,11 +7,11 @@
       "connection": "root:@(127.0.0.1:3306)/grid?tx_isolation=SERIALIZABLE&parseTime=true&interpolateParams=true"
   },
   "grid": {
+    "client_type": "selenium",
     "port": 4444,
     "strategy_list": [
       {
-        "type": "default",
-        "limit": 0
+        "type": "persistent"
       }
     ],
     "busy_node_duration": "15m",

config/config.go

@@ -16,15 +16,23 @@ type Config struct {
 }
 
 type Grid struct {
+	ClientType       string     `json:"client_type"`
 	Port             int        `json:"port"`
 	StrategyList     []Strategy `json:"strategy_list"`
 	BusyNodeDuration string     `json:"busy_node_duration"`     // duration string format ex. 12m, see time.ParseDuration()
 	ReservedDuration string     `json:"reserved_node_duration"` // duration string format ex. 12m, see time.ParseDuration()
 }
 
 type Strategy struct {
-	Type  string `json:"type"`
-	Limit int    `json:"limit"`
+	Params   json.RawMessage `json:"params"` // ex. docker config, kubernetes config, etc.
+	Type     string          `json:"type"`
+	Limit    int             `json:"limit"`
+	NodeList []Node          `json:"node_list"`
+}
+
+type Node struct {
+	Params           json.RawMessage          `json:"params"` // ex. image_name, etc.
+	CapabilitiesList []map[string]interface{} `json:"capabilities_list"`
 }
 
 type Logger struct {

handlers/createSession.go

@@ -7,25 +7,25 @@ import (
 	log "github.com/Sirupsen/logrus"
 	"github.com/qa-dev/jsonwire-grid/jsonwire"
 	"github.com/qa-dev/jsonwire-grid/pool"
+	"github.com/qa-dev/jsonwire-grid/pool/capabilities"
 	"github.com/qa-dev/jsonwire-grid/proxy"
-	"github.com/qa-dev/jsonwire-grid/selenium"
-	"github.com/qa-dev/jsonwire-grid/wda"
 	"io/ioutil"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
 )
 
 type CreateSession struct {
-	Pool *pool.Pool
+	Pool          *pool.Pool
+	ClientFactory jsonwire.ClientFactoryInterface
 }
 
 func (h *CreateSession) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		http.Error(rw, "Method Not Allowed", http.StatusMethodNotAllowed)
 		return
 	}
-	var capabilities map[string]jsonwire.Capabilities
+	var caps map[string]jsonwire.Capabilities
 	body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		errorMessage := "Error reading request: " + err.Error()
@@ -42,21 +42,21 @@ func (h *CreateSession) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	rc := ioutil.NopCloser(bytes.NewReader(body))
 	r.Body = rc
 	log.Infof("requested session with params: %s", string(body))
-	err = json.Unmarshal(body, &capabilities)
+	err = json.Unmarshal(body, &caps)
 	if err != nil {
 		errorMessage := "Error unmarshal json: " + err.Error()
 		log.Error(errorMessage)
 		http.Error(rw, errorMessage, http.StatusInternalServerError)
 		return
 	}
-	desiredCapabilities, ok := capabilities["desiredCapabilities"]
+	desiredCapabilities, ok := caps["desiredCapabilities"]
 	if !ok {
 		errorMessage := "Not passed 'desiredCapabilities'"
 		log.Error(errorMessage)
 		http.Error(rw, errorMessage, http.StatusInternalServerError)
 		return
 	}
-	poolCapabilities := pool.Capabilities(desiredCapabilities)
+	poolCapabilities := capabilities.Capabilities(desiredCapabilities)
 	tw, err := h.tryCreateSession(r, &poolCapabilities)
 	if err != nil {
 		http.Error(rw, "Can't create session: "+err.Error(), http.StatusInternalServerError)
@@ -66,7 +66,7 @@ func (h *CreateSession) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	rw.Write(tw.Output)
 }
 
-func (h *CreateSession) tryCreateSession(r *http.Request, capabilities *pool.Capabilities) (*proxy.ResponseWriter, error) {
+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())
@@ -79,16 +79,11 @@ func (h *CreateSession) tryCreateSession(r *http.Request, capabilities *pool.Cap
 		return nil, errors.New("reserve node error: " + err.Error())
 	}
 	//todo: посылать в мониторинг событие, если вернулся не 0
-	seleniumClient, err := createClient(node.Address, capabilities)
-	if err != nil {
-		return nil, errors.New("create Client error: " + err.Error())
-	}
+	seleniumClient := h.ClientFactory.Create(node.Address)
 	seleniumNode := jsonwire.NewNode(seleniumClient)
 	_, err = seleniumNode.RemoveAllSessions()
 	if err != nil {
-		log.Warn("Can't remove all sessions from node: " + err.Error() + ", go to next available node: " + node.String())
-		h.Pool.Remove(node)
-		return h.tryCreateSession(r, capabilities)
+		return nil, errors.New("Can't remove all sessions from node: " + err.Error() + ", go to next available node: " + node.String())
 	}
 	reverseProxy := httputil.NewSingleHostReverseProxy(&url.URL{
 		Scheme: "http",
@@ -100,23 +95,8 @@ func (h *CreateSession) tryCreateSession(r *http.Request, capabilities *pool.Cap
 	reverseProxy.ServeHTTP(tw, r)
 
 	if !transport.IsSuccess {
-		log.Warn("Failure proxy request on node " + node.String() + ": " + string(tw.Output))
-		h.Pool.Remove(node)
-		return h.tryCreateSession(r, capabilities)
+		return nil, errors.New("Failure proxy request on node " + node.String() + ": " + string(tw.Output))
 	}
 
 	return tw, nil
 }
-
-func createClient(addr string, capabilities *pool.Capabilities) (jsonwire.ClientInterface, error) {
-	if capabilities == nil {
-		return nil, errors.New("capabilities must be not nil")
-	}
-	platformName := (*capabilities)["platformName"]
-	switch platformName {
-	case "WDA":
-		return wda.NewClient(addr), nil
-	default:
-		return selenium.NewClient(addr), nil
-	}
-}

handlers/registerNode.go

@@ -9,6 +9,7 @@ import (
 	log "github.com/Sirupsen/logrus"
 	"github.com/qa-dev/jsonwire-grid/jsonwire"
 	"github.com/qa-dev/jsonwire-grid/pool"
+	"github.com/qa-dev/jsonwire-grid/pool/capabilities"
 )
 
 type RegisterNode struct {
@@ -41,12 +42,12 @@ func (h *RegisterNode) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	} else {
 		capabilitiesList = register.CapabilitiesList
 	}
-	poolCapabilitiesList := make([]pool.Capabilities, len(capabilitiesList))
+	poolCapabilitiesList := make([]capabilities.Capabilities, len(capabilitiesList))
 	for i, value := range capabilitiesList {
-		poolCapabilitiesList[i] = pool.Capabilities(value)
+		poolCapabilitiesList[i] = capabilities.Capabilities(value)
 	}
 	err = h.Pool.Add(
-		pool.NodeTypeRegular,
+		pool.NodeTypePersistent,
 		register.Configuration.Host+":"+strconv.Itoa(register.Configuration.Port),
 		poolCapabilitiesList,
 	)

invoke.go

@@ -5,11 +5,25 @@ import (
 	"github.com/qa-dev/jsonwire-grid/config"
 
 	"errors"
-	"github.com/qa-dev/jsonwire-grid/storage"
+	"github.com/qa-dev/jsonwire-grid/jsonwire"
+	"github.com/qa-dev/jsonwire-grid/pool"
+	"github.com/qa-dev/jsonwire-grid/pool/capabilities"
+	"github.com/qa-dev/jsonwire-grid/pool/strategy/kubernetes"
+	"github.com/qa-dev/jsonwire-grid/pool/strategy/persistent"
+	"github.com/qa-dev/jsonwire-grid/selenium"
 	"github.com/qa-dev/jsonwire-grid/storage/mysql"
+	"github.com/qa-dev/jsonwire-grid/wda"
 )
 
-func invokeStorageFactory(config config.Config) (factory storage.StorageFactoryInterface, err error) {
+type StorageFactoryInterface interface {
+	Create(config.Config) (pool.StorageInterface, error)
+}
+
+type StrategyFactoryInterface interface {
+	Create(pool.StorageInterface, capabilities.ComparatorInterface, jsonwire.ClientFactoryInterface) (pool.StrategyInterface, error)
+}
+
+func invokeStorageFactory(config config.Config) (factory StorageFactoryInterface, err error) {
 	switch config.DB.Implementation {
 	case "mysql":
 		factory = new(mysql.Factory)
@@ -18,3 +32,29 @@ func invokeStorageFactory(config config.Config) (factory storage.StorageFactoryI
 	}
 	return
 }
+
+func invokeStrategyFactoryList(config config.Config) (factoryList []StrategyFactoryInterface, err error) {
+	for _, strategyConfig := range config.Grid.StrategyList {
+		switch strategyConfig.Type {
+		case string(pool.NodeTypePersistent):
+			factoryList = append(factoryList, new(persistent.StrategyFactory))
+		case string(pool.NodeTypeKubernetes):
+			factoryList = append(factoryList, &kubernetes.StrategyFactory{Config: strategyConfig})
+		default:
+			err = errors.New("Undefined strategy type: " + strategyConfig.Type)
+			return
+		}
+	}
+	return
+}
+
+func createClient(config config.Config) (jsonwire.ClientFactoryInterface, error) {
+	switch config.Grid.ClientType {
+	case "wda":
+		return new(wda.ClientFactory), nil
+	case "selenium":
+		return new(selenium.ClientFactory), nil
+	default:
+		return nil, errors.New("undefined value config.Grid.ClientType")
+	}
+}

jsonwire/interfaces.go

@@ -1,6 +1,11 @@
 package jsonwire
 
+type ClientFactoryInterface interface {
+	Create(address string) ClientInterface
+}
+
 type ClientInterface interface {
+	Status() (*Message, error)
 	Sessions() (*Sessions, error)
 	CloseSession(sessionId string) (*Message, error)
 	Address() string

jsonwire/mocks.go

@@ -0,0 +1,38 @@
+package jsonwire
+
+import (
+	"github.com/stretchr/testify/mock"
+)
+
+type ClientFactoryMock struct {
+	mock.Mock
+}
+
+func (cf *ClientFactoryMock) Create(address string) ClientInterface {
+	args := cf.Called(address)
+	return args.Get(0).(ClientInterface)
+}
+
+type ClientMock struct {
+	mock.Mock
+}
+
+func (c *ClientMock) Status() (*Message, error) {
+	args := c.Called()
+	return args.Get(0).(*Message), args.Error(1)
+}
+
+func (c *ClientMock) Sessions() (*Sessions, error) {
+	args := c.Called()
+	return args.Get(0).(*Sessions), args.Error(1)
+}
+
+func (c *ClientMock) CloseSession(sessionId string) (*Message, error) {
+	args := c.Called(sessionId)
+	return args.Get(0).(*Message), args.Error(1)
+}
+
+func (c *ClientMock) Address() string {
+	args := c.Called()
+	return args.String(0)
+}

main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/qa-dev/jsonwire-grid/logger"
 	"github.com/qa-dev/jsonwire-grid/middleware"
 	"github.com/qa-dev/jsonwire-grid/pool"
+	"github.com/qa-dev/jsonwire-grid/pool/capabilities"
 	poolMetrics "github.com/qa-dev/jsonwire-grid/pool/metrics"
 	"github.com/qa-dev/jsonwire-grid/utils/metrics"
 	"net/http"
@@ -55,7 +56,28 @@ func main() {
 	if err != nil {
 		log.Fatalf("Can't create storage factory, %s", err)
 	}
-	poolInstance := pool.NewPool(storage)
+	capsComparator := capabilities.NewComparator()
+	strategyFactoryList, err := invokeStrategyFactoryList(*cfg)
+	if err != nil {
+		log.Fatalf("Can't create strategy factory list, %s", err)
+	}
+
+	clientFactory, err := createClient(*cfg)
+	if err != nil {
+		log.Fatalf("Create ClientFactory error, %s", err)
+	}
+
+	var strategyList []pool.StrategyInterface
+	for _, strategyFactory := range strategyFactoryList {
+		strategy, err := strategyFactory.Create(storage, capsComparator, clientFactory)
+		if err != nil {
+			log.Fatalf("Can't create strategy, %s", err)
+		}
+		strategyList = append(strategyList, strategy)
+	}
+
+	strategyListStruct := pool.NewStrategyList(strategyList)
+	poolInstance := pool.NewPool(storage, strategyListStruct)
 	poolInstance.SetBusyNodeDuration(busyNodeDuration)
 	poolInstance.SetReservedNodeDuration(reservedNodeDuration)
 
@@ -71,8 +93,8 @@ func main() {
 	}()
 
 	m := middleware.NewLogMiddleware(statsdClient)
-	http.Handle("/wd/hub/session", m.Log(&handlers.CreateSession{Pool: poolInstance})) //selenium
-	http.Handle("/session", m.Log(&handlers.CreateSession{Pool: poolInstance}))        //wda
+	http.Handle("/wd/hub/session", m.Log(&handlers.CreateSession{Pool: poolInstance, ClientFactory: clientFactory})) //selenium
+	http.Handle("/session", m.Log(&handlers.CreateSession{Pool: poolInstance, ClientFactory: clientFactory}))        //wda
 	http.Handle("/grid/register", m.Log(&handlers.RegisterNode{Pool: poolInstance}))
 	http.Handle("/grid/api/proxy", &handlers.ApiProxy{Pool: poolInstance})
 	http.HandleFunc("/_info", heartbeat)