Renamed old RoundRobin strategy to Random.

Added RoundRobin strategy.
Added StrategyFactory to config.

broker/broker.go

@@ -37,6 +37,9 @@ func mergeConfigs(baseConfig moleculer.Config, userConfig []*moleculer.Config) m
 			if config.TransporterFactory != nil {
 				baseConfig.TransporterFactory = config.TransporterFactory
 			}
+			if config.StrategyFactory != nil {
+				baseConfig.StrategyFactory = config.StrategyFactory
+			}
 			if config.DisableInternalMiddlewares {
 				baseConfig.DisableInternalMiddlewares = config.DisableInternalMiddlewares
 			}

moleculer.go

@@ -111,13 +111,15 @@ type Mixin struct {
 }
 
 type TransporterFactoryFunc func() interface{}
+type StrategyFactoryFunc func() interface{}
 
 type Config struct {
 	LogLevel                   string
 	LogFormat                  string
 	DiscoverNodeID             func() string
 	Transporter                string
 	TransporterFactory         TransporterFactoryFunc
+	StrategyFactory            StrategyFactoryFunc
 	HeartbeatFrequency         time.Duration
 	HeartbeatTimeout           time.Duration
 	OfflineCheckFrequency      time.Duration

registry/actionCatalog_test.go

@@ -12,7 +12,7 @@ import (
 
 var _ = Describe("Actions Catalog", func() {
 	logger := log.WithField("unit test pkg", "registry_test")
-	strategy := strategy.RoundRobinStrategy{}
+	strategy := strategy.RandomStrategy{}
 	params := moleculer.ObjectSchema{nil}
 	node1 := registry.CreateNode("node-test-1", true, logger)
 	node2 := registry.CreateNode("node-test-2", true, logger)

registry/registry.go

@@ -50,7 +50,11 @@ func createTransit(broker *moleculer.BrokerDelegates) transit.Transit {
 // createStrategy create a strsategy instance based on the config.
 func createStrategy(broker *moleculer.BrokerDelegates) strategy.Strategy {
 	//TODO: when new strategies are addes.. adde config check here to load the right one.
-	return strategy.RoundRobinStrategy{}
+	if broker.Config.StrategyFactory != nil {
+		return broker.Config.StrategyFactory().(strategy.Strategy)
+	}
+
+	return strategy.RandomStrategy{}
 }
 
 func CreateRegistry(nodeID string, broker *moleculer.BrokerDelegates) *ServiceRegistry {

strategy/random.go

@@ -0,0 +1,18 @@
+package strategy
+
+import (
+	"math/rand"
+)
+
+// RoundRobinStrategy exposes the type as a strategy option
+type RandomStrategy struct {
+}
+
+func (randomStrategy RandomStrategy) Select(nodes []Selector) *Selector {
+	if len(nodes) == 0 {
+		return nil
+	}
+	// Returns a number among the indexes up to the length
+	// of the slice
+	return &nodes[rand.Intn(len(nodes))]
+}

strategy/round-robin.go

@@ -1,18 +1,24 @@
 package strategy
 
-import (
-	"math/rand"
-)
-
 // RoundRobinStrategy exposes the type as a strategy option
 type RoundRobinStrategy struct {
+	counter int
+}
+
+func NewRoundRobinStrategy() Strategy {
+	return &RoundRobinStrategy{counter: -1}
 }
 
-func (roundRobinStrategy RoundRobinStrategy) Select(nodes []Selector) *Selector {
+func (roundRobinStrategy *RoundRobinStrategy) Select(nodes []Selector) *Selector {
 	if len(nodes) == 0 {
 		return nil
 	}
-	// Returns a number among the indexes up to the length
-	// of the slice
-	return &nodes[rand.Intn(len(nodes))]
+
+	roundRobinStrategy.counter++
+
+	if roundRobinStrategy.counter >= len(nodes) {
+		roundRobinStrategy.counter = 0
+	}
+
+	return &nodes[roundRobinStrategy.counter]
 }

strategy/strategy_suite_test.go

@@ -19,13 +19,13 @@ func (sel SelectorImpl) TargetNodeID() string {
 }
 
 var _ = Describe("Strategy", func() {
-	thisStrategy := strategy.RoundRobinStrategy{}
+	thisStrategy := strategy.RandomStrategy{}
 
 	list := []strategy.Selector{SelectorImpl{"alpha"}, SelectorImpl{"beta"}, SelectorImpl{"gamma"}, SelectorImpl{"delta"}}
 
 	emptyList := []strategy.Selector{}
 
-	It("Should return a ramdon target node according to strategy", func() {
+	It("Should return a random target node according to strategy", func() {
 		thisNode := thisStrategy.Select(list)
 		Expect(thisNode).Should(Not(BeNil()))
 	})