change docker compose using docker api sdk

cmd/world/cardinal/dev.go

@@ -18,8 +18,9 @@ import (
 
 	"pkg.world.dev/world-cli/common"
 	"pkg.world.dev/world-cli/common/config"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 	"pkg.world.dev/world-cli/common/logger"
-	"pkg.world.dev/world-cli/common/teacmd"
 	"pkg.world.dev/world-cli/tea/style"
 )
 
@@ -228,10 +229,17 @@ func startRedis(ctx context.Context, cfg *config.Config) error {
 	// Create an error group for managing redis lifecycle
 	group := new(errgroup.Group)
 
+	// Create docker client
+	dockerClient, err := docker.NewClient(cfg)
+	if err != nil {
+		return err
+	}
+	defer dockerClient.Close()
+
 	// Start Redis container
 	group.Go(func() error {
 		cfg.Detach = true
-		if err := teacmd.DockerStart(cfg, []teacmd.DockerService{teacmd.DockerServiceRedis}); err != nil {
+		if err := dockerClient.Start(ctx, cfg, service.Redis); err != nil {
 			return eris.Wrap(err, "Encountered an error with Redis")
 		}
 		return nil
@@ -243,7 +251,7 @@ func startRedis(ctx context.Context, cfg *config.Config) error {
 	// 2) The parent context is canceled for whatever reason.
 	group.Go(func() error {
 		<-ctx.Done()
-		if err := teacmd.DockerStop([]teacmd.DockerService{teacmd.DockerServiceRedis}); err != nil {
+		if err := dockerClient.Stop(cfg, service.Redis); err != nil {
 			return err
 		}
 		return nil

cmd/world/cardinal/purge.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"pkg.world.dev/world-cli/common/teacmd"
+	"pkg.world.dev/world-cli/common/config"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 )
 
 /////////////////
@@ -19,8 +21,20 @@ var purgeCmd = &cobra.Command{
 	Short: "Stop and reset the state of your Cardinal game shard",
 	Long: `Stop and reset the state of your Cardinal game shard.
 This command stop all Docker services and remove all Docker volumes.`,
-	RunE: func(_ *cobra.Command, _ []string) error {
-		err := teacmd.DockerPurge()
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		cfg, err := config.GetConfig(cmd)
+		if err != nil {
+			return err
+		}
+
+		// Create a new Docker client
+		dockerClient, err := docker.NewClient(cfg)
+		if err != nil {
+			return err
+		}
+		defer dockerClient.Close()
+
+		err = dockerClient.Purge(cfg, service.Nakama, service.Cardinal, service.NakamaDB, service.Redis)
 		if err != nil {
 			return err
 		}

cmd/world/cardinal/restart.go

@@ -4,7 +4,8 @@ import (
 	"github.com/spf13/cobra"
 
 	"pkg.world.dev/world-cli/common/config"
-	"pkg.world.dev/world-cli/common/teacmd"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 )
 
 // restartCmd restarts your Cardinal game shard stack
@@ -31,18 +32,14 @@ This will restart the following Docker services:
 			return err
 		}
 
-		if cfg.Debug {
-			err = teacmd.DockerRestart(cfg, []teacmd.DockerService{
-				teacmd.DockerServiceCardinalDebug,
-				teacmd.DockerServiceNakama,
-			})
-		} else {
-			err = teacmd.DockerRestart(cfg, []teacmd.DockerService{
-				teacmd.DockerServiceCardinal,
-				teacmd.DockerServiceNakama,
-			})
+		// Create docker client
+		dockerClient, err := docker.NewClient(cfg)
+		if err != nil {
+			return err
 		}
+		defer dockerClient.Close()
 
+		err = dockerClient.Restart(cmd.Context(), cfg, service.Cardinal, service.Nakama)
 		if err != nil {
 			return err
 		}

cmd/world/cardinal/start.go

@@ -11,7 +11,8 @@ import (
 
 	"pkg.world.dev/world-cli/common"
 	"pkg.world.dev/world-cli/common/config"
-	"pkg.world.dev/world-cli/common/teacmd"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 )
 
 /////////////////
@@ -110,9 +111,17 @@ This will start the following Docker services and its dependencies:
 
 		group, ctx := errgroup.WithContext(cmd.Context())
 
+		// Create docker client
+		dockerClient, err := docker.NewClient(cfg)
+		if err != nil {
+			return err
+		}
+		defer dockerClient.Close()
+
 		// Start the World Engine stack
 		group.Go(func() error {
-			if err := teacmd.DockerStartAll(cfg); err != nil {
+			if err := dockerClient.Start(ctx, cfg, service.NakamaDB,
+				service.Redis, service.Cardinal, service.Nakama); err != nil {
 				return eris.Wrap(err, "Encountered an error with Docker")
 			}
 			return eris.Wrap(ErrGracefulExit, "Stack terminated")

cmd/world/cardinal/stop.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"pkg.world.dev/world-cli/common/teacmd"
+	"pkg.world.dev/world-cli/common/config"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 )
 
 /////////////////
@@ -23,8 +25,20 @@ This will stop the following Docker services:
 - Cardinal (Game shard)
 - Nakama (Relay) + DB
 - Redis (Cardinal dependency)`,
-	RunE: func(_ *cobra.Command, _ []string) error {
-		err := teacmd.DockerStopAll()
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		cfg, err := config.GetConfig(cmd)
+		if err != nil {
+			return err
+		}
+
+		// Create docker client
+		dockerClient, err := docker.NewClient(cfg)
+		if err != nil {
+			return err
+		}
+		defer dockerClient.Close()
+
+		err = dockerClient.Stop(cfg, service.Nakama, service.Cardinal, service.NakamaDB, service.Redis)
 		if err != nil {
 			return err
 		}

cmd/world/evm/start.go

@@ -1,27 +1,21 @@
 package evm
 
 import (
-	"bytes"
+	"context"
 	"errors"
 	"fmt"
 	"net"
-	"os/exec"
-	"strings"
-	"time"
 
+	"github.com/rotisserie/eris"
 	"github.com/spf13/cobra"
 
 	"pkg.world.dev/world-cli/common/config"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 	"pkg.world.dev/world-cli/common/logger"
 	"pkg.world.dev/world-cli/common/teacmd"
 )
 
-var (
-	// Docker compose seems to replace the hyphen with an underscore. This could be properly fixed by removing the hyphen
-	// from celestia-devnet, or by investigating the docker compose documentation.
-	daContainer = strings.ReplaceAll(string(daService), "-", "_")
-)
-
 var startCmd = &cobra.Command{
 	Use:   "start",
 	Short: "Start the EVM base shard. Use --da-auth-token to pass in an auth token directly.",
@@ -32,7 +26,14 @@ var startCmd = &cobra.Command{
 			return err
 		}
 
-		if err = validateDALayer(cmd, cfg); err != nil {
+		// Create docker client
+		dockerClient, err := docker.NewClient(cfg)
+		if err != nil {
+			return err
+		}
+		defer dockerClient.Close()
+
+		if err = validateDALayer(cmd, cfg, dockerClient); err != nil {
 			return err
 		}
 
@@ -49,10 +50,18 @@ var startCmd = &cobra.Command{
 		cfg.Detach = false
 		cfg.Timeout = 0
 
-		err = teacmd.DockerStart(cfg, services(teacmd.DockerServiceEVM))
+		err = dockerClient.Start(cmd.Context(), cfg, service.EVM)
 		if err != nil {
 			return fmt.Errorf("error starting %s docker container: %w", teacmd.DockerServiceEVM, err)
 		}
+
+		// Stop the DA service if it was started in dev mode
+		if cfg.DevDA {
+			err = dockerClient.Stop(cfg, service.CelestiaDevNet)
+			if err != nil {
+				return eris.Wrap(err, "Failed to stop DA service")
+			}
+		}
 		return nil
 	},
 }
@@ -65,22 +74,18 @@ func init() {
 
 // validateDevDALayer starts a locally running version of the DA layer, and replaces the DA_AUTH_TOKEN configuration
 // variable with the token from the locally running container.
-func validateDevDALayer(cfg *config.Config) error {
+func validateDevDALayer(ctx context.Context, cfg *config.Config, dockerClient *docker.Client) error {
 	cfg.Build = true
 	cfg.Debug = false
 	cfg.Detach = true
 	cfg.Timeout = -1
 	logger.Println("starting DA docker service for dev mode...")
-	if err := teacmd.DockerStart(cfg, services(daService)); err != nil {
+	if err := dockerClient.Start(ctx, cfg, service.CelestiaDevNet); err != nil {
 		return fmt.Errorf("error starting %s docker container: %w", daService, err)
 	}
-
-	if err := blockUntilContainerIsRunning(daContainer, 10*time.Second); err != nil { //nolint:gomnd
-		return err
-	}
 	logger.Println("started DA service...")
 
-	daToken, err := getDAToken()
+	daToken, err := getDAToken(ctx, cfg, dockerClient)
 	if err != nil {
 		return err
 	}
@@ -121,58 +126,49 @@ func validateProdDALayer(cfg *config.Config) error {
 	return nil
 }
 
-func validateDALayer(cmd *cobra.Command, cfg *config.Config) error {
+func validateDALayer(cmd *cobra.Command, cfg *config.Config, dockerClient *docker.Client) error {
 	devDA, err := cmd.Flags().GetBool(FlagUseDevDA)
 	if err != nil {
 		return err
 	}
 	if devDA {
-		return validateDevDALayer(cfg)
+		cfg.DevDA = true
+		return validateDevDALayer(cmd.Context(), cfg, dockerClient)
 	}
 	return validateProdDALayer(cfg)
 }
 
-func getDAToken() (string, error) {
-	// Create a new command
-	maxRetries := 10
-	cmdString := fmt.Sprintf("docker exec %s celestia bridge --node.store /home/celestia/bridge/ auth admin",
-		daContainer)
-	cmdParts := strings.Split(cmdString, " ")
-	for retry := 0; retry < maxRetries; retry++ {
-		logger.Println("attempting to get DA token...")
-
-		cmd := exec.Command(cmdParts[0], cmdParts[1:]...) //nolint:gosec // not applicable
-		output, err := cmd.CombinedOutput()
-		if err != nil {
-			logger.Println("failed to get da token")
-			logger.Printf("%d/%d retrying...\n", retry+1, maxRetries)
-			time.Sleep(2 * time.Second) //nolint:gomnd
-			continue
-		}
+func getDAToken(ctx context.Context, cfg *config.Config, dockerClient *docker.Client) (string, error) {
+	fmt.Println("Getting DA token")
 
-		if bytes.Contains(output, []byte("\n")) {
-			return "", fmt.Errorf("da token should be a single line. got %v", string(output))
-		}
-		if len(output) == 0 {
-			return "", errors.New("got empty DA token")
-		}
-		return string(output), nil
+	containerName := service.CelestiaDevNet(cfg)
+
+	_, err := dockerClient.Exec(ctx, containerName.Name,
+		[]string{
+			"mkdir",
+			"-p",
+			"/home/celestia/bridge/keys",
+		})
+	if err != nil {
+		return "", eris.Wrap(err, "Failed to create keys directory")
 	}
-	return "", errors.New("timed out while getting DA token")
-}
 
-func blockUntilContainerIsRunning(targetContainer string, timeout time.Duration) error {
-	timeoutAt := time.Now().Add(timeout)
-	cmdString := "docker container inspect -f '{{.State.Running}}' " + targetContainer
-	// This string will be returned by the above command when the container is running
-	runningOutput := "'true'\n"
-	cmdParts := strings.Split(cmdString, " ")
-	for time.Now().Before(timeoutAt) {
-		output, err := exec.Command(cmdParts[0], cmdParts[1:]...).CombinedOutput() //nolint:gosec // not applicable
-		if err == nil && string(output) == runningOutput {
-			return nil
-		}
-		time.Sleep(250 * time.Millisecond) //nolint:gomnd
+	token, err := dockerClient.Exec(ctx, containerName.Name,
+		[]string{
+			"celestia",
+			"bridge",
+			"--node.store",
+			"/home/celestia/bridge/",
+			"auth",
+			"admin",
+		})
+
+	if err != nil {
+		return "", eris.Wrapf(err, "Failed to get DA token")
+	}
+
+	if token == "" {
+		return "", errors.New("got empty DA token")
 	}
-	return fmt.Errorf("timeout while waiting for %q to start", targetContainer)
+	return token, nil
 }

cmd/world/evm/stop.go

@@ -5,15 +5,29 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"pkg.world.dev/world-cli/common/teacmd"
+	"pkg.world.dev/world-cli/common/config"
+	"pkg.world.dev/world-cli/common/docker"
+	"pkg.world.dev/world-cli/common/docker/service"
 )
 
 var stopCmd = &cobra.Command{
 	Use:   "stop",
 	Short: "Stop the EVM base shard and DA layer client.",
 	Long:  "Stop the EVM base shard and data availability layer client if they are running.",
-	RunE: func(_ *cobra.Command, _ []string) error {
-		err := teacmd.DockerStop(services(teacmd.DockerServiceEVM, teacmd.DockerServiceDA))
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		cfg, err := config.GetConfig(cmd)
+		if err != nil {
+			return err
+		}
+
+		// Create docker client
+		dockerClient, err := docker.NewClient(cfg)
+		if err != nil {
+			return err
+		}
+		defer dockerClient.Close()
+
+		err = dockerClient.Stop(cfg, service.EVM, service.CelestiaDevNet)
 		if err != nil {
 			return err
 		}