strategies

- abstractions
- tests
- persistent strategy

Author: Mikhail Podtserkovskiy

config-sample.json

@@ -10,8 +10,7 @@
     "port": 4444,
     "strategy_list": [
       {
-        "type": "default",
-        "limit": 0
+        "type": "persistent"
       }
     ],
     "busy_node_duration": "15m",

config-test.json

@@ -10,8 +10,7 @@
     "port": 4444,
     "strategy_list": [
       {
-        "type": "default",
-        "limit": 0
+        "type": "persistent"
       }
     ],
     "busy_node_duration": "15m",

config/config.go

@@ -23,8 +23,16 @@ type Grid struct {
 }
 
 type Strategy struct {
-	Type  string `json:"type"`
-	Limit int    `json:"limit"`
+	Config   map[string]string `json:"config"` // ex. docker config, kubernetes config, etc.
+	Type     string            `json:"type"`
+	Limit    int               `json:"limit"`
+	NodeList []Node            `json:"node_list"`
+}
+
+type Node struct {
+	Config       map[string]string      `json:"config"` // ex. image_name, etc.
+	Capabilities map[string]interface{} `json:"capabilities"`
+	Limit        int                    `json:"limit"`
 }
 
 type Logger struct {

handlers/registerNode.go

@@ -46,7 +46,7 @@ func (h *RegisterNode) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 		poolCapabilitiesList[i] = pool.Capabilities(value)
 	}
 	err = h.Pool.Add(
-		pool.NodeTypeRegular,
+		pool.NodeTypePersistent,
 		register.Configuration.Host+":"+strconv.Itoa(register.Configuration.Port),
 		poolCapabilitiesList,
 	)

invoke.go

@@ -5,11 +5,20 @@ import (
 	"github.com/qa-dev/jsonwire-grid/config"
 
 	"errors"
-	"github.com/qa-dev/jsonwire-grid/storage"
+	"github.com/qa-dev/jsonwire-grid/pool"
+	"github.com/qa-dev/jsonwire-grid/pool/strategy/persistent"
 	"github.com/qa-dev/jsonwire-grid/storage/mysql"
 )
 
-func invokeStorageFactory(config config.Config) (factory storage.StorageFactoryInterface, err error) {
+type StorageFactoryInterface interface {
+	Create(config.Config) (pool.StorageInterface, error)
+}
+
+type StrategyFactoryInterface interface {
+	Create(config.Config, pool.StorageInterface) (pool.StrategyInterface, error)
+}
+
+func invokeStorageFactory(config config.Config) (factory StorageFactoryInterface, err error) {
 	switch config.DB.Implementation {
 	case "mysql":
 		factory = new(mysql.Factory)
@@ -18,3 +27,18 @@ func invokeStorageFactory(config config.Config) (factory storage.StorageFactoryI
 	}
 	return
 }
+
+func invokeStrategyFactoryList(config config.Config, storage pool.StorageInterface) (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, new(kubernetes.StrategyFactory))
+		default:
+			err = errors.New("Undefined strategy type: " + strategyConfig.Type)
+			return
+		}
+	}
+	return
+}

main.go

@@ -55,7 +55,21 @@ func main() {
 	if err != nil {
 		log.Fatalf("Can't create storage factory, %s", err)
 	}
-	poolInstance := pool.NewPool(storage)
+	strategyFactoryList, err := invokeStrategyFactoryList(*cfg, storage)
+	if err != nil {
+		log.Fatalf("Can't create strategy factory list, %s", err)
+	}
+	var strategyList []pool.StrategyInterface
+	for _, strategyFactory := range strategyFactoryList {
+		strategy, err := strategyFactory.Create(*cfg, storage)
+		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)
 

pool/node.go

@@ -11,8 +11,8 @@ const (
 type NodeType string
 
 const (
-	NodeTypeRegular   NodeType = "regular"
-	NodeTypeTemporary NodeType = "temporary"
+	NodeTypePersistent NodeType = "persistent"
+	NodeTypeKubernetes NodeType = "kubernetes"
 )
 
 type Node struct {

pool/pool.go

@@ -26,14 +26,25 @@ type StorageInterface interface {
 	Remove(Node) error
 }
 
+type StrategyInterface interface {
+	Reserve(Capabilities) (Node, error)
+	CleanUp(Node) error
+}
+
 type Pool struct {
 	storage              StorageInterface
 	busyNodeDuration     time.Duration
 	reservedNodeDuration time.Duration
+	strategyList         StrategyListInterface
 }
 
-func NewPool(storage StorageInterface) *Pool {
-	return &Pool{storage, defaultBusyNodeDuration, defaultReservedNodeDuration}
+func NewPool(storage StorageInterface, strategyList StrategyListInterface) *Pool {
+	return &Pool{
+		storage:              storage,
+		busyNodeDuration:     defaultBusyNodeDuration,
+		reservedNodeDuration: defaultReservedNodeDuration,
+		strategyList:         strategyList,
+	}
 }
 
 func (p *Pool) SetBusyNodeDuration(duration time.Duration) {
@@ -45,11 +56,12 @@ func (p *Pool) SetReservedNodeDuration(duration time.Duration) {
 }
 
 // TODO: research close transaction and defer close mysql result body.
-func (p *Pool) ReserveAvailableNode(capabilities Capabilities) (*Node, error) {
-	node, err := p.storage.ReserveAvailable(capabilities)
+func (p *Pool) ReserveAvailableNode(caps Capabilities) (*Node, error) {
+	node, err := p.strategyList.Reserve(caps)
 	if err != nil {
 		err = errors.New("Can't reserve available node, " + err.Error())
 		log.Error(err)
+		return nil, err
 	}
 	return &node, err
 }
@@ -91,7 +103,7 @@ func (p *Pool) GetNodeByAddress(address string) (*Node, error) {
 }
 
 func (p *Pool) CleanUpNode(node *Node) error {
-	err := p.storage.SetAvailable(*node)
+	err := p.strategyList.CleanUp(*node)
 	if err != nil {
 		err = errors.New("Can't clean up node: " + err.Error())
 		log.Error(err)