rename some types

Author: algorandskiy

network/hybridNetwork.go

@@ -34,12 +34,12 @@ type HybridP2PNetwork struct {
 	wsNetwork  *WebsocketNetwork
 
 	useP2PAddress bool
-	meshStrategy  meshStrategy
+	mesher        mesher
 }
 
 // NewHybridP2PNetwork constructs a GossipNode that combines P2PNetwork and WebsocketNetwork
 // Hybrid mode requires both P2P and WS to be running in server (NetAddress set) or client (NetAddress empty) mode.
-func NewHybridP2PNetwork(log logging.Logger, cfg config.Local, datadir string, phonebookAddresses []string, genesisInfo GenesisInfo, nodeInfo NodeInfo, meshCreator MeshStrategyCreator) (*HybridP2PNetwork, error) {
+func NewHybridP2PNetwork(log logging.Logger, cfg config.Local, datadir string, phonebookAddresses []string, genesisInfo GenesisInfo, nodeInfo NodeInfo, meshCreator MeshCreator) (*HybridP2PNetwork, error) {
 	if err := cfg.ValidateP2PHybridConfig(); err != nil {
 		return nil, err
 	}
@@ -49,15 +49,15 @@ func NewHybridP2PNetwork(log logging.Logger, cfg config.Local, datadir string, p
 	p2pcfg.IncomingConnectionsLimit = cfg.P2PHybridIncomingConnectionsLimit
 	identityTracker := NewIdentityTracker()
 
-	var subnetMeshCreator MeshStrategyCreator = meshCreator
-	var hybridMeshCreator MeshStrategyCreator = &noopMeshStrategyCreator{}
-	_, isHybridMeshCreator := meshCreator.(*HybridRelayMeshStrategyCreator)
+	var subnetMeshCreator MeshCreator = meshCreator
+	var hybridMeshCreator MeshCreator = &noopMeshCreator{}
+	_, isHybridMeshCreator := meshCreator.(*HybridRelayMeshCreator)
 	if meshCreator == nil && cfg.IsHybridServer() || isHybridMeshCreator {
-		// no mesh strategy provided and this node is a listening/relaying node
-		// then override and use hybrid relay meshing strategy
-		// or, if a hybrid relay strategy requested explicitly, do the same
-		subnetMeshCreator = &noopMeshStrategyCreator{}
-		hybridMeshCreator = &HybridRelayMeshStrategyCreator{}
+		// no mesh creator provided and this node is a listening/relaying node
+		// then override and use hybrid relay meshing
+		// or, if a hybrid relay meshing requested explicitly, do the same
+		subnetMeshCreator = &noopMeshCreator{}
+		hybridMeshCreator = &HybridRelayMeshCreator{}
 	}
 
 	p2pnet, err := NewP2PNetwork(log, p2pcfg, datadir, phonebookAddresses, genesisInfo, nodeInfo, &identityOpts{tracker: identityTracker}, subnetMeshCreator)
@@ -74,17 +74,17 @@ func NewHybridP2PNetwork(log logging.Logger, cfg config.Local, datadir string, p
 		return nil, err
 	}
 
-	hybridMeshStrategy, err := hybridMeshCreator.create(
+	hybridMesh, err := hybridMeshCreator.create(
 		withWebsocketNetwork(wsnet),
 		withP2PNetwork(p2pnet))
 	if err != nil {
-		return nil, fmt.Errorf("failed to create hybrid mesh strategy: %w", err)
+		return nil, fmt.Errorf("failed to create hybrid mesh: %w", err)
 	}
 
 	hn := &HybridP2PNetwork{
-		p2pNetwork:   p2pnet,
-		wsNetwork:    wsnet,
-		meshStrategy: hybridMeshStrategy,
+		p2pNetwork: p2pnet,
+		wsNetwork:  wsnet,
+		mesher:     hybridMesh,
 	}
 
 	return hn, nil
@@ -204,7 +204,7 @@ func (n *HybridP2PNetwork) Start() error {
 	if err != nil {
 		return err
 	}
-	n.meshStrategy.start()
+	n.mesher.start()
 	return nil
 }
 
@@ -215,7 +215,7 @@ func (n *HybridP2PNetwork) Stop() {
 		return nil
 	})
 
-	n.meshStrategy.stop()
+	n.mesher.stop()
 }
 
 // RegisterHandlers adds to the set of given message handlers.

network/hybridNetwork_test.go

@@ -47,7 +47,7 @@ func TestHybridNetwork_DuplicateConn(t *testing.T) {
 
 	relayCfg := cfg
 	relayCfg.ForceRelayMessages = true
-	netA, err := NewHybridP2PNetwork(log.With("node", "netA"), relayCfg, p2pKeyDir, nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshStrategyCreator{})
+	netA, err := NewHybridP2PNetwork(log.With("node", "netA"), relayCfg, p2pKeyDir, nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshCreator{})
 	require.NoError(t, err)
 
 	err = netA.Start()
@@ -66,7 +66,7 @@ func TestHybridNetwork_DuplicateConn(t *testing.T) {
 	relayCfg.NetAddress = addr
 	relayCfg.PublicAddress = addr
 	relayCfg.P2PHybridNetAddress = "127.0.0.1:0"
-	netA, err = NewHybridP2PNetwork(log.With("node", "netA"), relayCfg, p2pKeyDir, nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshStrategyCreator{})
+	netA, err = NewHybridP2PNetwork(log.With("node", "netA"), relayCfg, p2pKeyDir, nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshCreator{})
 	require.NoError(t, err)
 
 	err = netA.Start()
@@ -87,14 +87,14 @@ func TestHybridNetwork_DuplicateConn(t *testing.T) {
 
 	phoneBookAddresses := []string{multiAddrStr, addr}
 
-	netB, err := NewHybridP2PNetwork(log.With("node", "netB"), cfg, "", phoneBookAddresses, genesisInfo, &nopeNodeInfo{}, &BaseMeshStrategyCreator{})
+	netB, err := NewHybridP2PNetwork(log.With("node", "netB"), cfg, "", phoneBookAddresses, genesisInfo, &nopeNodeInfo{}, &BaseMeshCreator{})
 	require.NoError(t, err)
 	// for netB start the p2p network first
 	err = netB.p2pNetwork.Start()
 	require.NoError(t, err)
 	defer netB.Stop()
 
-	netC, err := NewHybridP2PNetwork(log.With("node", "netC"), cfg, "", phoneBookAddresses, genesisInfo, &nopeNodeInfo{}, &BaseMeshStrategyCreator{})
+	netC, err := NewHybridP2PNetwork(log.With("node", "netC"), cfg, "", phoneBookAddresses, genesisInfo, &nopeNodeInfo{}, &BaseMeshCreator{})
 	require.NoError(t, err)
 	// for netC start the ws network first
 	err = netC.wsNetwork.Start()
@@ -193,12 +193,12 @@ func TestHybridNetwork_ValidateConfig(t *testing.T) {
 	cfg.P2PHybridNetAddress = ""
 	genesisInfo := GenesisInfo{genesisID, "net"}
 
-	_, err := NewHybridP2PNetwork(logging.TestingLog(t), cfg, "", nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshStrategyCreator{})
+	_, err := NewHybridP2PNetwork(logging.TestingLog(t), cfg, "", nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshCreator{})
 	require.ErrorContains(t, err, "both NetAddress and P2PHybridNetAddress")
 
 	cfg.NetAddress = ""
 	cfg.P2PHybridNetAddress = ":0"
-	_, err = NewHybridP2PNetwork(logging.TestingLog(t), cfg, "", nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshStrategyCreator{})
+	_, err = NewHybridP2PNetwork(logging.TestingLog(t), cfg, "", nil, genesisInfo, &nopeNodeInfo{}, &BaseMeshCreator{})
 	require.ErrorContains(t, err, "both NetAddress and P2PHybridNetAddress")
 }
 

network/mesh.go

@@ -28,13 +28,12 @@ import (
 
 const meshThreadInterval = time.Minute
 
-type meshStrategy interface {
-	meshThread()
+type mesher interface {
 	start()
 	stop()
 }
 
-type baseMeshStrategy struct {
+type baseMesher struct {
 	wg sync.WaitGroup
 	meshConfig
 }
@@ -44,18 +43,18 @@ type meshConfig struct {
 	meshUpdateRequests chan meshRequest
 	meshThreadInterval time.Duration
 	backoff            backoff.BackoffStrategy
-	netMesh            func() bool
-	peerStatReport     func()
+	netMeshFn          func() bool
+	peerStatReporter   func()
 	closer             func()
 
 	// wsnet and p2pnet are used in hybrid relay mode
 	wsnet  *WebsocketNetwork
 	p2pnet *P2PNetwork
 }
 
-type meshStrategyOption func(*meshConfig)
+type meshOption func(*meshConfig)
 
-func withMeshExpJitterBackoff() meshStrategyOption {
+func withMeshExpJitterBackoff() meshOption {
 	return func(cfg *meshConfig) {
 		// Add exponential backoff with jitter to the mesh thread to handle new networks startup
 		// when no DNS or DHT peers are available.
@@ -66,61 +65,61 @@ func withMeshExpJitterBackoff() meshStrategyOption {
 		cfg.backoff = eb
 	}
 }
-func withMeshNetMesh(netMesh func() bool) meshStrategyOption {
+func withMeshNetMeshFn(netMeshFn func() bool) meshOption {
 	return func(cfg *meshConfig) {
-		cfg.netMesh = netMesh
+		cfg.netMeshFn = netMeshFn
 	}
 }
-func withMeshPeerStatReport(peerStatReport func()) meshStrategyOption {
+func withMeshPeerStatReporter(peerStatReporter func()) meshOption {
 	return func(cfg *meshConfig) {
-		cfg.peerStatReport = peerStatReport
+		cfg.peerStatReporter = peerStatReporter
 	}
 }
-func withMeshCloser(closer func()) meshStrategyOption {
+func withMeshCloser(closer func()) meshOption {
 	return func(cfg *meshConfig) {
 		cfg.closer = closer
 	}
 }
 
-func withMeshUpdateRequest(ch chan meshRequest) meshStrategyOption {
+func withMeshUpdateRequest(ch chan meshRequest) meshOption {
 	return func(cfg *meshConfig) {
 		cfg.meshUpdateRequests = ch
 	}
 }
 
-func withMeshUpdateInterval(d time.Duration) meshStrategyOption {
+func withMeshUpdateInterval(d time.Duration) meshOption {
 	return func(cfg *meshConfig) {
 		cfg.meshThreadInterval = d
 	}
 }
 
-func withContext(ctx context.Context) meshStrategyOption {
+func withContext(ctx context.Context) meshOption {
 	return func(cfg *meshConfig) {
 		cfg.ctx = ctx
 	}
 }
 
-func withWebsocketNetwork(wsnet *WebsocketNetwork) meshStrategyOption {
+func withWebsocketNetwork(wsnet *WebsocketNetwork) meshOption {
 	return func(cfg *meshConfig) {
 		cfg.wsnet = wsnet
 	}
 }
 
-func withP2PNetwork(p2pnet *P2PNetwork) meshStrategyOption {
+func withP2PNetwork(p2pnet *P2PNetwork) meshOption {
 	return func(cfg *meshConfig) {
 		cfg.p2pnet = p2pnet
 	}
 }
 
-func newBaseMeshStrategy(opts ...meshStrategyOption) (*baseMeshStrategy, error) {
+func newBaseMesher(opts ...meshOption) (*baseMesher, error) {
 	var cfg meshConfig
 	for _, opt := range opts {
 		opt(&cfg)
 	}
 	if cfg.ctx == nil {
 		return nil, errors.New("context is not set")
 	}
-	if cfg.netMesh == nil {
+	if cfg.netMeshFn == nil {
 		return nil, errors.New("mesh function is not set")
 	}
 	if cfg.meshUpdateRequests == nil {
@@ -130,12 +129,12 @@ func newBaseMeshStrategy(opts ...meshStrategyOption) (*baseMeshStrategy, error)
 		cfg.meshThreadInterval = meshThreadInterval
 	}
 
-	return &baseMeshStrategy{
+	return &baseMesher{
 		meshConfig: cfg,
 	}, nil
 }
 
-func (m *baseMeshStrategy) meshThread() {
+func (m *baseMesher) meshThread() {
 	defer m.wg.Done()
 
 	timer := time.NewTicker(m.meshThreadInterval)
@@ -150,7 +149,7 @@ func (m *baseMeshStrategy) meshThread() {
 			return
 		}
 
-		hasPeers := m.netMesh()
+		hasPeers := m.netMeshFn()
 		if m.backoff != nil {
 			if hasPeers {
 				// found something, reset timer to the configured value
@@ -168,41 +167,41 @@ func (m *baseMeshStrategy) meshThread() {
 		// send the currently connected peers information to the
 		// telemetry server; that would allow the telemetry server
 		// to construct a cross-node map of all the nodes interconnections.
-		m.peerStatReport()
+		m.peerStatReporter()
 	}
 }
 
-func (m *baseMeshStrategy) start() {
+func (m *baseMesher) start() {
 	m.wg.Add(1)
 	go m.meshThread()
 }
 
-func (m *baseMeshStrategy) stop() {
+func (m *baseMesher) stop() {
 	m.wg.Wait()
 	if m.closer != nil {
 		m.closer()
 	}
 }
 
-// MeshStrategyCreator is an interface for creating mesh strategies.
-type MeshStrategyCreator interface {
-	create(opts ...meshStrategyOption) (meshStrategy, error)
+// MeshCreator is an interface for creating mesh strategies.
+type MeshCreator interface {
+	create(opts ...meshOption) (mesher, error)
 }
 
-// BaseMeshStrategyCreator is a creator for the base mesh strategy used in our standard WS or P2P implementations:
+// BaseMeshCreator is a creator for the base mesh strategy used in our standard WS or P2P implementations:
 // run a mesh thread that periodically checks for new peers.
-type BaseMeshStrategyCreator struct {
+type BaseMeshCreator struct {
 }
 
-func (c *BaseMeshStrategyCreator) create(opts ...meshStrategyOption) (meshStrategy, error) {
-	return newBaseMeshStrategy(opts...)
+func (c *BaseMeshCreator) create(opts ...meshOption) (mesher, error) {
+	return newBaseMesher(opts...)
 }
 
-// HybridRelayMeshStrategyCreator is a creator for the hybrid relay mesh strategy used in hybrid relays:
+// HybridRelayMeshCreator is a creator for the hybrid relay mesh strategy used in hybrid relays:
 // always use wsnet nodes
-type HybridRelayMeshStrategyCreator struct{}
+type HybridRelayMeshCreator struct{}
 
-func (c *HybridRelayMeshStrategyCreator) create(opts ...meshStrategyOption) (meshStrategy, error) {
+func (c *HybridRelayMeshCreator) create(opts ...meshOption) (mesher, error) {
 	var cfg meshConfig
 	for _, opt := range opts {
 		opt(&cfg)
@@ -215,12 +214,12 @@ func (c *HybridRelayMeshStrategyCreator) create(opts ...meshStrategyOption) (mes
 	out := make(chan meshRequest, 5)
 	var wg sync.WaitGroup
 
-	creator := BaseMeshStrategyCreator{}
+	creator := BaseMeshCreator{}
 	ctx := cfg.wsnet.ctx
-	strategy, err := creator.create(
+	mesh, err := creator.create(
 		withContext(ctx),
-		withMeshNetMesh(cfg.wsnet.meshThreadInner),
-		withMeshPeerStatReport(func() {
+		withMeshNetMeshFn(cfg.wsnet.meshThreadInner),
+		withMeshPeerStatReporter(func() {
 			cfg.p2pnet.peerStater.sendPeerConnectionsTelemetryStatus(cfg.wsnet)
 			cfg.p2pnet.peerStater.sendPeerConnectionsTelemetryStatus(cfg.p2pnet)
 		}),
@@ -256,20 +255,18 @@ func (c *HybridRelayMeshStrategyCreator) create(opts ...meshStrategyOption) (mes
 		}
 	}()
 
-	return strategy, nil
+	return mesh, nil
 }
 
-type noopMeshStrategyCreator struct{}
+type noopMeshCreator struct{}
 
-func (c *noopMeshStrategyCreator) create(opts ...meshStrategyOption) (meshStrategy, error) {
-	return &noopMeshStrategy{}, nil
+func (c *noopMeshCreator) create(opts ...meshOption) (mesher, error) {
+	return &noopMesh{}, nil
 }
 
-type noopMeshStrategy struct{}
+type noopMesh struct{}
 
-func (m *noopMeshStrategy) meshThread() {
+func (m *noopMesh) start() {
 }
-func (m *noopMeshStrategy) start() {
-}
-func (m *noopMeshStrategy) stop() {
+func (m *noopMesh) stop() {
 }