[FAB-14328] de-vipererize gossip discovery

Inject configuration of discovery via struct,
and not through viper getter invocations.
Have the viper config at higher levels.

Change-Id: I6d51256679d2ebf80eb50684dc903f3da91af76b
Signed-off-by: Hagar Meir <hagar.meir@ibm.com>

Author: HagarMeir

gossip/discovery/discovery_impl.go

@@ -23,33 +23,14 @@ import (
 	"github.com/pkg/errors"
 )
 
-const defaultHelloInterval = time.Duration(5) * time.Second
+const DefAliveTimeInterval = 5 * time.Second
+const DefAliveExpirationTimeout = 5 * DefAliveTimeInterval
+const DefAliveExpirationCheckInterval = DefAliveExpirationTimeout / 10
+const DefReconnectInterval = DefAliveExpirationTimeout
 const msgExpirationFactor = 20
 
-var aliveExpirationCheckInterval time.Duration
 var maxConnectionAttempts = 120
 
-// SetAliveTimeInterval sets the alive time interval
-func SetAliveTimeInterval(interval time.Duration) {
-	util.SetVal("peer.gossip.aliveTimeInterval", interval)
-}
-
-// SetAliveExpirationTimeout sets the expiration timeout
-func SetAliveExpirationTimeout(timeout time.Duration) {
-	util.SetVal("peer.gossip.aliveExpirationTimeout", timeout)
-	aliveExpirationCheckInterval = time.Duration(timeout / 10)
-}
-
-// SetAliveExpirationCheckInterval sets the expiration check interval
-func SetAliveExpirationCheckInterval(interval time.Duration) {
-	aliveExpirationCheckInterval = interval
-}
-
-// SetReconnectInterval sets the reconnect interval
-func SetReconnectInterval(interval time.Duration) {
-	util.SetVal("peer.gossip.reconnectInterval", interval)
-}
-
 // SetMaxConnAttempts sets the maximum number of connection
 // attempts the peer would perform when invoking Connect()
 func SetMaxConnAttempts(attempts int) {
@@ -96,8 +77,16 @@ type gossipDiscoveryImpl struct {
 	reconnectInterval            time.Duration
 }
 
+type DiscoveryConfig struct {
+	AliveTimeInterval            time.Duration
+	AliveExpirationTimeout       time.Duration
+	AliveExpirationCheckInterval time.Duration
+	ReconnectInterval            time.Duration
+}
+
 // NewDiscoveryService returns a new discovery service with the comm module passed and the crypto service passed
-func NewDiscoveryService(self NetworkMember, comm CommService, crypt CryptoService, disPol DisclosurePolicy) Discovery {
+func NewDiscoveryService(self NetworkMember, comm CommService, crypt CryptoService, disPol DisclosurePolicy,
+	config DiscoveryConfig) Discovery {
 	d := &gossipDiscoveryImpl{
 		self:             self,
 		incTime:          uint64(time.Now().UnixNano()),
@@ -116,10 +105,10 @@ func NewDiscoveryService(self NetworkMember, comm CommService, crypt CryptoServi
 		disclosurePolicy: disPol,
 		pubsub:           util.NewPubSub(),
 
-		aliveTimeInterval:            getAliveTimeInterval(),
-		aliveExpirationTimeout:       getAliveExpirationTimeout(),
-		aliveExpirationCheckInterval: getAliveExpirationCheckInterval(),
-		reconnectInterval:            getReconnectInterval(),
+		aliveTimeInterval:            config.AliveTimeInterval,
+		aliveExpirationTimeout:       config.AliveExpirationTimeout,
+		aliveExpirationCheckInterval: config.AliveExpirationCheckInterval,
+		reconnectInterval:            config.ReconnectInterval,
 	}
 
 	d.validateSelfConfig()
@@ -1017,26 +1006,6 @@ func before(a *timestamp, b *proto.PeerTime) bool {
 		uint64(a.incTime.UnixNano()) < b.IncNum
 }
 
-func getAliveTimeInterval() time.Duration {
-	return util.GetDurationOrDefault("peer.gossip.aliveTimeInterval", defaultHelloInterval)
-}
-
-func getAliveExpirationTimeout() time.Duration {
-	return util.GetDurationOrDefault("peer.gossip.aliveExpirationTimeout", 5*getAliveTimeInterval())
-}
-
-func getAliveExpirationCheckInterval() time.Duration {
-	if aliveExpirationCheckInterval != 0 {
-		return aliveExpirationCheckInterval
-	}
-
-	return time.Duration(getAliveExpirationTimeout() / 10)
-}
-
-func getReconnectInterval() time.Duration {
-	return util.GetDurationOrDefault("peer.gossip.reconnectInterval", getAliveExpirationTimeout())
-}
-
 type aliveMsgStore struct {
 	msgstore.MessageStore
 }

gossip/discovery/discovery_test.go

@@ -22,26 +22,27 @@ import (
 	"time"
 
 	protoG "github.com/golang/protobuf/proto"
-	"github.com/hyperledger/fabric/core/config/configtest"
 	"github.com/hyperledger/fabric/gossip/common"
 	"github.com/hyperledger/fabric/gossip/gossip/msgstore"
 	"github.com/hyperledger/fabric/gossip/util"
 	proto "github.com/hyperledger/fabric/protos/gossip"
-	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"google.golang.org/grpc"
 )
 
 var timeout = time.Second * time.Duration(15)
 
+var aliveTimeInterval = time.Duration(time.Millisecond * 300)
+var config = DiscoveryConfig{
+	AliveTimeInterval:            aliveTimeInterval,
+	AliveExpirationTimeout:       10 * aliveTimeInterval,
+	AliveExpirationCheckInterval: aliveTimeInterval,
+	ReconnectInterval:            10 * aliveTimeInterval,
+}
+
 func init() {
 	util.SetupTestLogging()
-	aliveTimeInterval := time.Duration(time.Millisecond * 300)
-	SetAliveTimeInterval(aliveTimeInterval)
-	SetAliveExpirationTimeout(10 * aliveTimeInterval)
-	SetAliveExpirationCheckInterval(aliveTimeInterval)
-	SetReconnectInterval(10 * aliveTimeInterval)
 	maxConnectionAttempts = 10000
 }
 
@@ -383,7 +384,7 @@ func createDiscoveryInstanceThatGossipsWithInterceptors(port int, id string, boo
 	}
 	s := grpc.NewServer()
 
-	discSvc := NewDiscoveryService(self, comm, comm, pol)
+	discSvc := NewDiscoveryService(self, comm, comm, pol, config)
 	for _, bootPeer := range bootstrapPeers {
 		bp := bootPeer
 		discSvc.Connect(NetworkMember{Endpoint: bp, InternalEndpoint: bootPeer}, func() (*PeerIdentification, error) {
@@ -774,12 +775,12 @@ func TestInitiateSync(t *testing.T) {
 				if atomic.LoadInt32(&toDie) == int32(1) {
 					return
 				}
-				time.Sleep(getAliveExpirationTimeout() / 3)
+				time.Sleep(config.AliveExpirationTimeout / 3)
 				inst.InitiateSync(9)
 			}
 		}()
 	}
-	time.Sleep(getAliveExpirationTimeout() * 4)
+	time.Sleep(config.AliveExpirationTimeout * 4)
 	assertMembership(t, instances, nodeNum-1)
 	atomic.StoreInt32(&toDie, int32(1))
 	stopInstances(t, instances)
@@ -1040,7 +1041,7 @@ func createDisjointPeerGroupsWithNoGossip(bootPeerMap map[int]int) ([]*gossipIns
 			bootPeers := []string{bootPeer(bootPeerMap[port])}
 			pol := discPolForPeer(port)
 			inst := createDiscoveryInstanceWithNoGossipWithDisclosurePolicy(8610+group*5+i, id, bootPeers, pol)
-			inst.initiateSync(getAliveExpirationTimeout()/3, 10)
+			inst.initiateSync(config.AliveExpirationTimeout/3, 10)
 			if group == 0 {
 				instances1 = append(instances1, inst)
 			} else {
@@ -1083,44 +1084,6 @@ func discPolForPeer(selfPort int) DisclosurePolicy {
 	}
 }
 
-func TestConfigFromFile(t *testing.T) {
-	preAliveTimeInterval := getAliveTimeInterval()
-	preAliveExpirationTimeout := getAliveExpirationTimeout()
-	preAliveExpirationCheckInterval := getAliveExpirationCheckInterval()
-	preReconnectInterval := getReconnectInterval()
-
-	// Recover the config values in order to avoid impacting other tests
-	defer func() {
-		SetAliveTimeInterval(preAliveTimeInterval)
-		SetAliveExpirationTimeout(preAliveExpirationTimeout)
-		SetAliveExpirationCheckInterval(preAliveExpirationCheckInterval)
-		SetReconnectInterval(preReconnectInterval)
-	}()
-
-	// Verify if using default values when config is missing
-	viper.Reset()
-	aliveExpirationCheckInterval = 0 * time.Second
-	assert.Equal(t, time.Duration(5)*time.Second, getAliveTimeInterval())
-	assert.Equal(t, time.Duration(25)*time.Second, getAliveExpirationTimeout())
-	assert.Equal(t, time.Duration(25)*time.Second/10, getAliveExpirationCheckInterval())
-	assert.Equal(t, time.Duration(25)*time.Second, getReconnectInterval())
-
-	//Verify reading the values from config file
-	viper.Reset()
-	aliveExpirationCheckInterval = 0 * time.Second
-	viper.SetConfigName("core")
-	viper.SetEnvPrefix("CORE")
-	configtest.AddDevConfigPath(nil)
-	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
-	viper.AutomaticEnv()
-	err := viper.ReadInConfig()
-	assert.NoError(t, err)
-	assert.Equal(t, time.Duration(5)*time.Second, getAliveTimeInterval())
-	assert.Equal(t, time.Duration(25)*time.Second, getAliveExpirationTimeout())
-	assert.Equal(t, time.Duration(25)*time.Second/10, getAliveExpirationCheckInterval())
-	assert.Equal(t, time.Duration(25)*time.Second, getReconnectInterval())
-}
-
 func TestMsgStoreExpiration(t *testing.T) {
 	// Starts 4 instances, wait for membership to build, stop 2 instances
 	// Check that membership in 2 running instances become 2
@@ -1187,7 +1150,7 @@ func TestMsgStoreExpiration(t *testing.T) {
 		return true
 	}
 
-	waitUntilTimeoutOrFail(t, checkMessages, getAliveExpirationTimeout()*(msgExpirationFactor+5))
+	waitUntilTimeoutOrFail(t, checkMessages, config.AliveExpirationTimeout*(msgExpirationFactor+5))
 
 	assertMembership(t, instances[:len(instances)-2], nodeNum-3)
 
@@ -1339,7 +1302,7 @@ func TestMsgStoreExpirationWithMembershipMessages(t *testing.T) {
 	}
 
 	// Sleep until expire
-	time.Sleep(getAliveExpirationTimeout() * (msgExpirationFactor + 5))
+	time.Sleep(config.AliveExpirationTimeout * (msgExpirationFactor + 5))
 
 	// Checking Alive expired
 	for i := 0; i < peersNum; i++ {

gossip/gossip/gossip.go

@@ -145,4 +145,10 @@ type Config struct {
 	SendBuffSize int           // Buffer size of sending messages
 
 	MsgExpirationTimeout time.Duration // Leadership message expiration timeout
+
+	AliveTimeInterval            time.Duration // Alive check interval
+	AliveExpirationTimeout       time.Duration // Alive expiration timeout
+	AliveExpirationCheckInterval time.Duration // Alive expiration check interval
+	ReconnectInterval            time.Duration // Reconnect interval
+
 }

gossip/gossip/gossip_impl.go

@@ -118,7 +118,15 @@ func NewGossipService(conf *Config, s *grpc.Server, sa api.SecurityAdvisor,
 
 	g.discAdapter = g.newDiscoveryAdapter()
 	g.disSecAdap = g.newDiscoverySecurityAdapter()
-	g.disc = discovery.NewDiscoveryService(g.selfNetworkMember(), g.discAdapter, g.disSecAdap, g.disclosurePolicy)
+
+	discoveryConfig := discovery.DiscoveryConfig{
+		AliveTimeInterval:            conf.AliveTimeInterval,
+		AliveExpirationTimeout:       conf.AliveExpirationTimeout,
+		AliveExpirationCheckInterval: conf.AliveExpirationCheckInterval,
+		ReconnectInterval:            conf.ReconnectInterval,
+	}
+	g.disc = discovery.NewDiscoveryService(g.selfNetworkMember(), g.discAdapter, g.disSecAdap, g.disclosurePolicy,
+		discoveryConfig)
 	g.logger.Infof("Creating gossip service with self membership of %s", g.selfNetworkMember())
 
 	g.certPuller = g.createCertStorePuller()