Merge pull request #115 from ethpandaops/feat/xcli-xatu

Author: mattevans

cmd/xcli/main.go

@@ -103,6 +103,7 @@ func main() {
 	// Add stack commands
 	rootCmd.AddCommand(commands.NewLabCommand(log, configPath))
 	rootCmd.AddCommand(commands.NewCCCommand(log, configPath))
+	rootCmd.AddCommand(commands.NewXatuCommand(log, configPath))
 
 	// Execute
 	if err := rootCmd.ExecuteContext(ctx); err != nil {

pkg/commands/completion_helpers.go

@@ -3,6 +3,7 @@ package commands
 import (
 	"io"
 
+	"github.com/ethpandaops/xcli/pkg/compose"
 	"github.com/ethpandaops/xcli/pkg/config"
 	"github.com/ethpandaops/xcli/pkg/constants"
 	"github.com/ethpandaops/xcli/pkg/orchestrator"
@@ -90,3 +91,33 @@ func completeReleasableProjects() func(*cobra.Command, []string, string) ([]stri
 		return completions, cobra.ShellCompDirectiveNoFileComp
 	}
 }
+
+// completeXatuServices returns a ValidArgsFunction that completes xatu service names.
+// It loads the xatu config, creates a compose runner, and lists available services.
+func completeXatuServices(configPath string) func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
+	return func(cmd *cobra.Command, args []string, _ string) ([]string, cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		log := logrus.New()
+		log.SetOutput(io.Discard)
+
+		xatuCfg, _, err := config.LoadXatuConfig(configPath)
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		runner, err := compose.NewRunner(log, xatuCfg.Repos.Xatu, xatuCfg.Profiles, xatuCfg.EnvOverrides)
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		services, err := runner.ListServices(cmd.Context())
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		return services, cobra.ShellCompDirectiveNoFileComp
+	}
+}

pkg/commands/init.go

@@ -21,6 +21,7 @@ func NewInitCommand(log logrus.FieldLogger, configPath string) *cobra.Command {
 This command creates an empty configuration file that you can then populate
 by running stack-specific init commands:
   - xcli lab init      (initialize lab stack configuration)
+  - xcli xatu init     (initialize xatu stack configuration)
   - xcli <stack> init  (initialize other stack configurations)
 
 If the configuration file already exists, this command will exit without changes.`,
@@ -42,6 +43,7 @@ func runRootInit(log logrus.FieldLogger, configPath string) error {
 		ui.Blank()
 		ui.Info("To initialize specific stacks, run:")
 		fmt.Println("  xcli lab init        - Initialize lab stack")
+		fmt.Println("  xcli xatu init       - Initialize xatu stack")
 		fmt.Println("  xcli <stack> init    - Initialize other stacks")
 
 		return nil
@@ -64,7 +66,8 @@ func runRootInit(log logrus.FieldLogger, configPath string) error {
 	ui.Blank()
 	ui.Header("Next steps:")
 	fmt.Println("  1. Run 'xcli lab init' to discover and configure lab repositories")
-	fmt.Println("  2. Run 'xcli <stack> init' for other stacks as needed")
+	fmt.Println("  2. Run 'xcli xatu init' to configure the xatu stack")
+	fmt.Println("  3. Run 'xcli <stack> init' for other stacks as needed")
 	fmt.Printf("  3. Edit %s to customize settings\n", configPath)
 
 	return nil

pkg/commands/xatu.go

@@ -0,0 +1,57 @@
+package commands
+
+import (
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+// NewXatuCommand creates the xatu command namespace.
+func NewXatuCommand(log logrus.FieldLogger, configPath string) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "xatu",
+		Short: "Manage the xatu docker-compose stack",
+		Long: `Manage the xatu docker-compose stack for local development.
+
+The xatu stack is entirely docker-compose based, running ~25 services
+including ClickHouse, Kafka, Grafana, and the various xatu components.
+
+Common workflows:
+  1. Initial setup:
+     xcli xatu init           # Discover xatu repo, verify Docker
+     xcli xatu check          # Verify environment is ready
+     xcli xatu up             # Start the stack
+
+  2. Development:
+     (make code changes)
+     xcli xatu rebuild xatu-server   # Rebuild and restart a service
+     xcli xatu status                # Check service status
+     xcli xatu logs xatu-server -f   # Stream logs
+
+  3. Service control:
+     xcli xatu stop <service>     # Stop a specific service
+     xcli xatu start <service>    # Start a specific service
+     xcli xatu restart <service>  # Restart a specific service
+
+  4. Teardown:
+     xcli xatu down              # Stop all containers
+     xcli xatu clean             # Remove everything including volumes and images
+
+Use 'xcli xatu [command] --help' for more information about a command.`,
+	}
+
+	// Add xatu subcommands
+	cmd.AddCommand(NewXatuInitCommand(log, configPath))
+	cmd.AddCommand(NewXatuCheckCommand(log, configPath))
+	cmd.AddCommand(NewXatuUpCommand(log, configPath))
+	cmd.AddCommand(NewXatuDownCommand(log, configPath))
+	cmd.AddCommand(NewXatuCleanCommand(log, configPath))
+	cmd.AddCommand(NewXatuStatusCommand(log, configPath))
+	cmd.AddCommand(NewXatuStartCommand(log, configPath))
+	cmd.AddCommand(NewXatuStopCommand(log, configPath))
+	cmd.AddCommand(NewXatuRestartCommand(log, configPath))
+	cmd.AddCommand(NewXatuLogsCommand(log, configPath))
+	cmd.AddCommand(NewXatuBuildCommand(log, configPath))
+	cmd.AddCommand(NewXatuRebuildCommand(log, configPath))
+
+	return cmd
+}

pkg/commands/xatu_build.go

@@ -0,0 +1,52 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/ethpandaops/xcli/pkg/config"
+	"github.com/ethpandaops/xcli/pkg/ui"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+// NewXatuBuildCommand creates the xatu build command.
+func NewXatuBuildCommand(log logrus.FieldLogger, configPath string) *cobra.Command {
+	return &cobra.Command{
+		Use:   "build [service...]",
+		Short: "Build xatu docker images",
+		Long: `Build docker images for xatu services without starting them.
+
+If no service is specified, all services with build configurations are built.
+
+Examples:
+  xcli xatu build                   # Build all images
+  xcli xatu build xatu-server       # Build just xatu-server image`,
+		ValidArgsFunction: completeXatuServices(configPath),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			xatuCfg, _, err := config.LoadXatuConfig(configPath)
+			if err != nil {
+				return fmt.Errorf("failed to load config: %w", err)
+			}
+
+			runner, err := newXatuRunner(log, xatuCfg)
+			if err != nil {
+				return fmt.Errorf("failed to create compose runner: %w", err)
+			}
+
+			ui.Header("Building xatu images...")
+			ui.Blank()
+
+			if err := runner.Build(cmd.Context(), args...); err != nil {
+				ui.Blank()
+				ui.Error("Build failed")
+
+				return err
+			}
+
+			ui.Blank()
+			ui.Success("Build complete")
+
+			return nil
+		},
+	}
+}

pkg/commands/xatu_check.go

@@ -0,0 +1,145 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/ethpandaops/xcli/pkg/config"
+	"github.com/ethpandaops/xcli/pkg/ui"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+// NewXatuCheckCommand creates the xatu check command.
+func NewXatuCheckCommand(log logrus.FieldLogger, configPath string) *cobra.Command {
+	return &cobra.Command{
+		Use:   "check",
+		Short: "Verify xatu environment is ready",
+		Long: `Perform health checks on the xatu environment without starting services.
+
+Verifies:
+  - Configuration file exists and is valid
+  - Xatu repo exists with docker-compose.yml
+  - Docker daemon is running and accessible
+  - Docker Compose is available
+  - Warns about potential port conflicts with lab stack
+
+Exit codes:
+  0 - All checks passed
+  1 - One or more checks failed
+
+Example:
+  xcli xatu check`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runXatuCheck(cmd.Context(), log, configPath)
+		},
+	}
+}
+
+func runXatuCheck(ctx context.Context, log logrus.FieldLogger, configPath string) error {
+	ui.Header("Running xatu environment health checks...")
+
+	allPassed := true
+
+	// Check 1: Configuration file
+	spinner := ui.NewSpinner("Checking configuration file")
+
+	xatuCfg, _, err := config.LoadXatuConfig(configPath)
+	if err != nil {
+		spinner.Fail(fmt.Sprintf("Configuration file error: %v", err))
+
+		allPassed = false
+	} else {
+		spinner.Success("Configuration file valid")
+	}
+
+	// Check 2: Configuration validity
+	if xatuCfg != nil {
+		spinner = ui.NewSpinner("Validating configuration")
+
+		if err := xatuCfg.Validate(); err != nil {
+			spinner.Fail(fmt.Sprintf("Configuration validation failed: %v", err))
+
+			allPassed = false
+		} else {
+			spinner.Success("Configuration valid")
+		}
+
+		// Check 3: docker-compose.yml
+		spinner = ui.NewSpinner("Checking docker-compose.yml")
+
+		absRepo, _ := filepath.Abs(xatuCfg.Repos.Xatu)
+		composePath := filepath.Join(absRepo, "docker-compose.yml")
+
+		if _, statErr := statFile(composePath); statErr != nil {
+			spinner.Fail(fmt.Sprintf("docker-compose.yml not found: %s", composePath))
+
+			allPassed = false
+		} else {
+			spinner.Success("docker-compose.yml found")
+		}
+	}
+
+	// Check 4: Docker
+	spinner = ui.NewSpinner("Checking Docker daemon")
+
+	cmd := exec.CommandContext(ctx, "docker", "info")
+	if err := cmd.Run(); err != nil {
+		spinner.Fail("Docker daemon not accessible - Ensure Docker Desktop is running")
+
+		allPassed = false
+	} else {
+		spinner.Success("Docker daemon accessible")
+	}
+
+	// Check 5: Docker Compose
+	spinner = ui.NewSpinner("Checking Docker Compose")
+
+	cmd = exec.CommandContext(ctx, "docker", "compose", "version")
+	if err := cmd.Run(); err != nil {
+		spinner.Fail("Docker Compose not available")
+
+		allPassed = false
+	} else {
+		spinner.Success("Docker Compose available")
+	}
+
+	// Check 6: Port conflict warning with lab stack
+	checkPortConflicts(log, configPath)
+
+	// Summary
+	ui.Blank()
+
+	if allPassed {
+		ui.Success("All checks passed! Environment is ready.")
+
+		ui.Header("Next steps:")
+		fmt.Println("  xcli xatu up              # Start the xatu stack")
+		fmt.Println("  xcli xatu up --build      # Start with image rebuild")
+
+		return nil
+	}
+
+	ui.Error("Some checks failed. Please resolve the issues above.")
+
+	return fmt.Errorf("environment checks failed")
+}
+
+// checkPortConflicts warns about potential port conflicts between xatu and lab stacks.
+func checkPortConflicts(log logrus.FieldLogger, configPath string) {
+	result, err := config.Load(configPath)
+	if err != nil || result.Config.Lab == nil || result.Config.Xatu == nil {
+		return
+	}
+
+	// Both stacks are configured - warn about common port conflicts
+	ui.Blank()
+	ui.Warning("Both lab and xatu stacks are configured. Common port conflicts:")
+	fmt.Println("  - Grafana (3000), Prometheus (9090), ClickHouse (8123)")
+	ui.Info("Use xatu.envOverrides in .xcli.yaml to remap xatu ports, e.g.:")
+	fmt.Println("  xatu:")
+	fmt.Println("    envOverrides:")
+	fmt.Println("      GRAFANA_PORT: \"3001\"")
+}