Playground basic command line

Author: 0x19

cmd/playground.go

@@ -0,0 +1,64 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/unpackdev/fdb/playground"
+	"github.com/urfave/cli/v2"
+	"go.uber.org/zap"
+)
+
+const (
+	DefaultBasePort  = 50000
+	DefaultNodeCount = 5
+)
+
+// PlaygroundCommand returns a cli.Command that plays with the real clients over simulated network
+func PlaygroundCommand() *cli.Command {
+	return &cli.Command{
+		Name:  "playground",
+		Usage: "Play with (f)db clients over simulated network",
+		Flags: []cli.Flag{
+			&cli.IntFlag{
+				Name:    "base-port",
+				Aliases: []string{"p"},
+				Value:   DefaultBasePort,
+				Usage:   "Base port for the nodes (each node will use this port + index)",
+			},
+			&cli.IntFlag{
+				Name:    "node-count",
+				Aliases: []string{"n"},
+				Value:   DefaultNodeCount,
+				Usage:   "Number of nodes to start in the playground",
+			},
+			&cli.StringFlag{
+				Name:    "log-level",
+				Aliases: []string{"l"},
+				Value:   "debug",
+				Usage:   "Log level (debug, info, warn, error)",
+			},
+		},
+		Action: func(c *cli.Context) error {
+			// Create a config with defaults that can be overridden by CLI flags
+			config := playground.Config{
+				BasePort:  DefaultBasePort,
+				NodeCount: DefaultNodeCount,
+				LogLevel:  zap.NewAtomicLevelAt(zap.DebugLevel),
+			}
+
+			// Parse log level if provided
+			if c.IsSet("log-level") {
+				logLevelStr := c.String("log-level")
+				level, err := zap.ParseAtomicLevel(logLevelStr)
+				if err != nil {
+					return fmt.Errorf("invalid log level: %w", err)
+				}
+
+				config.LogLevel = level
+			}
+
+			// Run the playground with both the context and config
+			return playground.Run(c, config)
+		},
+	}
+}

entrypoint/main.go

@@ -1,22 +1,24 @@
 package main
 
 import (
-	"github.com/unpackdev/fdb/cmd"
-	"github.com/urfave/cli/v2"
 	"log"
 	"os"
+
+	"github.com/unpackdev/fdb/cmd"
+	"github.com/urfave/cli/v2"
 )
 
 func main() {
 	app := &cli.App{
 		Name:  "(f)db",
 		Usage: "Fast Database Transports",
 		Commands: []*cli.Command{
-			cmd.CertsCommand(),     // Command for handling certificates
-			cmd.BenchmarkCommand(), // Command for running benchmarks
-			cmd.EbpfCommands(),     // Command for running eBPF specific workload
-			cmd.ServeCommand(),     // Command to start the server
-			cmd.KeystoreCommand(),  // Command for handling keystore (Peer IDs)
+			cmd.CertsCommand(),      // Command for handling certificates
+			cmd.BenchmarkCommand(),  // Command for running benchmarks
+			cmd.EbpfCommands(),      // Command for running eBPF specific workload
+			cmd.ServeCommand(),      // Command to start the server
+			cmd.KeystoreCommand(),   // Command for handling keystore (Peer IDs)
+			cmd.PlaygroundCommand(), // Command for playing with real clients over simulated network
 		},
 	}
 

playground/README.md

@@ -0,0 +1,8 @@
+# Playground
+
+This directory is used for testing and playing around with different things. Idea is to have a place where we can spawn
+as many as possible nodes we want and see them in grafana dashboard how they behave. Behaviour include:
+
+- Network, latencies and availability
+- RPC
+- Raw TCP and Capn Proto

playground/entrypoint.go

@@ -0,0 +1,110 @@
+package playground
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/unpackdev/fdb/pkg/rbac"
+	"github.com/unpackdev/fdb/pkg/types"
+	"github.com/unpackdev/fdb/playground/suite"
+	"github.com/urfave/cli/v2"
+	"go.uber.org/zap"
+)
+
+// Config holds the configuration for the playground environment
+type Config struct {
+	BasePort  int
+	NodeCount int
+	LogLevel  zap.AtomicLevel
+}
+
+// Run initializes and runs the playground environment based on the provided CLI context and config
+func Run(cliCtx *cli.Context, config Config) error {
+	// Create a cancelable context
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Use configuration from config parameter, overridden by CLI flags if provided
+	basePort := config.BasePort
+	if basePort == 0 {
+		basePort = 9000
+	}
+	if cliCtx.IsSet("base-port") {
+		basePort = cliCtx.Int("base-port")
+	}
+	
+	nodeCount := config.NodeCount
+	if nodeCount == 0 {
+		nodeCount = 5
+	}
+	if cliCtx.IsSet("node-count") {
+		nodeCount = cliCtx.Int("node-count")
+	}
+	
+	logLevel := zap.InfoLevel
+	if config.LogLevel.Level() != zap.InfoLevel {
+		logLevel = config.LogLevel.Level()
+	}
+	if cliCtx.IsSet("debug") && cliCtx.Bool("debug") {
+		logLevel = zap.DebugLevel
+	}
+
+	// Define the node roles
+	roles := make([]types.Role, nodeCount)
+	for i := range roles {
+		roles[i] = rbac.RoleNode
+	}
+
+	// Initialize the nodes
+	fmt.Printf("Initializing %d nodes with base port %d...\n", nodeCount, basePort)
+	nodes, err := suite.InitializeNodes(
+		ctx,
+		logLevel,
+		types.Ed25519SignerType,
+		roles,
+		basePort,
+		types.TCPTransportType,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to initialize nodes: %w", err)
+	}
+
+	// Ensure we clean up nodes when exiting
+	defer func() {
+		fmt.Println("Shutting down nodes...")
+		if err := suite.ShutdownTestNodes(nodes); err != nil {
+			fmt.Printf("Error shutting down nodes: %v\n", err)
+		}
+	}()
+
+	// Print node information
+	fmt.Println("Playground nodes initialized:")
+	for i, node := range nodes {
+		fmt.Printf("Node %d: PeerID=%s, Role=%s\n", i, node.PeerID().String(), node.Role())
+	}
+
+	// Wait for nodes to connect to each other
+	fmt.Println("Waiting for nodes to connect to each other...")
+	for i, node := range nodes {
+		// Minus one because own peer needs to be excluded
+		if err := node.WaitForPeersConnected(len(roles)-1, 10*time.Second); err != nil {
+			fmt.Printf("Warning: Node %d didn't connect to all peers in time: %v\n", i, err)
+		}
+	}
+
+	// Setup a signal handler for graceful shutdown
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+
+	fmt.Println("Playground environment is ready!")
+	fmt.Println("Press Ctrl+C to exit...")
+
+	// Wait for interrupt signal
+	<-sigCh
+	fmt.Println("Received interrupt signal, shutting down playground...")
+	return nil
+}