Basic networks strategy that just runs the network itself

Author: 0x19

cmd/playground.go

@@ -69,15 +69,36 @@ func writeStrategyFlags() []cli.Flag {
 	}
 }
 
+// networkStrategyFlags returns the flags specific to the network strategy
+func networkStrategyFlags() []cli.Flag {
+	return []cli.Flag{
+		&cli.IntFlag{
+			Name:    "duration",
+			Aliases: []string{"d"},
+			Value:   60,
+			Usage:   "Duration to run the network test in seconds",
+		},
+		&cli.IntFlag{
+			Name:    "ping-timeout",
+			Aliases: []string{"t"},
+			Value:   5,
+			Usage:   "Timeout for each ping operation in seconds",
+		},
+	}
+}
+
+// PlaygroundCommand returns a cli.Command for running playground environments
 func PlaygroundCommand() *cli.Command {
 	return &cli.Command{
-		Name:  "playground",
-		Usage: "Play with (f)db clients over simulated network",
+		Name:        "playground",
+		Usage:       "Run playground environments for testing and demos",
+		Description: "Playground provides a simple environment for spawning multiple nodes and running test strategies",
 		Subcommands: []*cli.Command{
 			{
-				Name:  "network",
-				Usage: "Run just the network without any specific test strategy",
-				Flags: commonFlags(),
+				Name:        "network",
+				Usage:       "Run a network connectivity test",
+				Description: "Tests the P2P network connectivity between all nodes",
+				Flags:       append(commonFlags(), networkStrategyFlags()...),
 				Action: func(c *cli.Context) error {
 					config := playground.Config{
 						BasePort:  DefaultBasePort,

playground/registry/strategies.go

@@ -14,4 +14,7 @@ var AvailableStrategies = map[string]RegistryFn{
 	"write": func(logger logger.Logger) strategies.Strategy {
 		return strategies.NewWriteStrategy(logger, nil) // Nodes will be provided later
 	},
+	"network": func(logger logger.Logger) strategies.Strategy {
+		return strategies.NewNetworkStrategy(logger, nil) // Nodes will be provided later
+	},
 }

playground/strategies/network.go

@@ -0,0 +1,155 @@
+package strategies
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/unpackdev/fdb/pkg/logger"
+	"github.com/unpackdev/fdb/playground/suite"
+)
+
+// NetworkStrategy tests the network connectivity between nodes
+type NetworkStrategy struct {
+	logger      logger.Logger
+	nodes       suite.TestNodes
+	doneCh      chan struct{}
+	cancel      context.CancelFunc
+	duration    time.Duration
+	wg          sync.WaitGroup
+	pingTimeout time.Duration
+}
+
+// NewNetworkStrategy creates a new network strategy
+func NewNetworkStrategy(logger logger.Logger, nodes suite.TestNodes) *NetworkStrategy {
+	return &NetworkStrategy{
+		logger:      logger,
+		nodes:       nodes,
+		doneCh:      make(chan struct{}),
+		duration:    60 * time.Second, // Run for 1 minute by default
+		pingTimeout: 5 * time.Second,
+	}
+}
+
+// Info returns information about the network strategy
+func (s *NetworkStrategy) Info() Info {
+	return Info{
+		Name:        "network",
+		Description: "Tests network connectivity between nodes",
+		DefaultArgs: map[string]any{
+			"duration":     60, // seconds
+			"ping_timeout": 5,  // seconds
+		},
+		ArgMappings: []ArgMapping{
+			{
+				Flag:         "duration",
+				ParamKey:     "duration",
+				Description:  "Duration to run the network test in seconds",
+				DefaultValue: 60,
+			},
+			{
+				Flag:         "ping-timeout",
+				ParamKey:     "ping_timeout",
+				Description:  "Timeout for each ping operation in seconds",
+				DefaultValue: 5,
+			},
+		},
+	}
+}
+
+// Start begins the network connectivity testing
+func (s *NetworkStrategy) Start(ctx context.Context) error {
+	s.logger.Info("Starting network connectivity testing",
+		"node_count", len(s.nodes),
+		"duration", s.duration.String(),
+		"ping_timeout", s.pingTimeout.String())
+
+	// Create a new context we can cancel when Stop is called
+	ctx, s.cancel = context.WithCancel(ctx)
+	
+	s.wg.Add(1)
+	go s.runConnectivityTest(ctx)
+
+	// Set up the completion timer
+	go func() {
+		timer := time.NewTimer(s.duration)
+		defer timer.Stop()
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-timer.C:
+			s.logger.Info("Network test completed successfully")
+			close(s.doneCh)
+			if s.cancel != nil {
+				s.cancel()
+			}
+		}
+	}()
+
+	return nil
+}
+
+// Stop halts the network strategy
+func (s *NetworkStrategy) Stop() error {
+	if s.cancel != nil {
+		s.cancel()
+	}
+	s.wg.Wait()
+	return nil
+}
+
+// CompletionCh returns a channel that is closed when the strategy completes
+func (s *NetworkStrategy) CompletionCh() <-chan struct{} {
+	return s.doneCh
+}
+
+// CreateFn returns a function that can create new instances of this strategy
+func (s *NetworkStrategy) CreateFn() StrategyFn {
+	return func(logger logger.Logger, nodes suite.TestNodes, args map[string]any) (Strategy, error) {
+		strategy := NewNetworkStrategy(logger, nodes)
+		
+		// Apply configuration from args
+		if durationSec, ok := args["duration"].(int); ok && durationSec > 0 {
+			strategy.duration = time.Duration(durationSec) * time.Second
+		}
+		
+		if timeout, ok := args["ping_timeout"].(int); ok && timeout > 0 {
+			strategy.pingTimeout = time.Duration(timeout) * time.Second
+		}
+		
+		return strategy, nil
+	}
+}
+
+// runConnectivityTest periodically checks connectivity between nodes
+func (s *NetworkStrategy) runConnectivityTest(ctx context.Context) {
+	defer s.wg.Done()
+	
+	ticker := time.NewTicker(10 * time.Second)
+	defer ticker.Stop()
+	
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			s.checkConnectivity()
+		}
+	}
+}
+
+// checkConnectivity verifies that all nodes can see each other
+func (s *NetworkStrategy) checkConnectivity() {
+	totalNodes := len(s.nodes)
+	s.logger.Info("Checking network connectivity", "total_nodes", totalNodes)
+	
+	for i, node := range s.nodes {
+		peers := node.Node().Network().Host().Network().Peers()
+		s.logger.Info("Node connectivity status", 
+			"node_index", i,
+			"peer_id", node.PeerID().String(),
+			"connected_peers", len(peers),
+			"expected_peers", totalNodes-1) // Exclude self
+	}
+}

playground/suite/suite.go

@@ -168,7 +168,7 @@ func (t *TestNode) WaitForPeersConnected(expectedPeerCount int, timeout time.Dur
 	for {
 		select {
 		case <-timeoutCh:
-			return fmt.Errorf("timeout waiting for validator %s to connect to peers", t.PeerID())
+			return fmt.Errorf("timeout waiting for node %s to connect to peers", t.PeerID())
 		case <-ticker.C:
 			peers := t.node.Network().Host().Network().Peers()
 			if len(peers) >= expectedPeerCount {
@@ -267,25 +267,6 @@ func InitializeNodes(
 				BasePath: dir,
 				Keys:     []config.Key{}, // Keys are generated dynamically...
 			},
-			Observability: config.Observability{
-				Metrics: config.MetricsConfig{
-					Enable:         false,
-					Exporter:       "prometheus",
-					Endpoint:       "0.0.0.0:9090",
-					Headers:        map[string]string{},
-					ExportInterval: 15 * time.Second,
-					SampleRate:     1.0,
-				},
-				Tracing: config.TracingConfig{
-					Enable:         false,
-					Exporter:       "otlp",
-					Endpoint:       "localhost:4317",
-					Headers:        map[string]string{},
-					Sampler:        "always_on",
-					SamplingRate:   1.0,
-					ExportInterval: 15 * time.Second,
-				},
-			},
 			Transports: []config.Transport{
 				{
 					Type:    types.TCPTransportType,
@@ -313,6 +294,25 @@ func InitializeNodes(
 					TLS:     nil,
 				},
 			},
+			Observability: config.Observability{
+				Metrics: config.MetricsConfig{
+					Enable:         true,
+					Exporter:       "prometheus",
+					Endpoint:       "localhost:4317",
+					Headers:        map[string]string{},
+					ExportInterval: 15 * time.Second,
+					SampleRate:     1.0,
+				},
+				Tracing: config.TracingConfig{
+					Enable:         true,
+					Exporter:       "otlp",
+					Endpoint:       "localhost:4317",
+					Headers:        map[string]string{},
+					Sampler:        "always_on",
+					SamplingRate:   0.1,
+					ExportInterval: 15 * time.Second,
+				},
+			},
 		}
 
 		// Initialize the logger
@@ -435,7 +435,7 @@ func InitializeNodes(
 
 	for _, tNode := range nodes {
 		// Minus one because own peer needs to be excluded
-		wpcErr := tNode.WaitForPeersConnected(len(nodeRoles)-1, 10*time.Second)
+		wpcErr := tNode.WaitForPeersConnected(len(nodeRoles)-1, 30*time.Second)
 		if wpcErr != nil {
 			return nil, fmt.Errorf("failure to establish mutual node connectivity: %w", wpcErr)
 		}