testing: embedded Etcd server

Author: grussorusso

internal/node/pool.go

@@ -307,7 +307,7 @@ func dismissContainer(requiredMemoryMB int64) (bool, error) {
 		}
 	}
 
-cleanup:                               // Phase 2: Cleanup
+cleanup: // Phase 2: Cleanup
 	if cleanedMB >= requiredMemoryMB { // if we'd actually free enough memory we do it, otherwise there's no point
 		for _, item := range containerToDismiss {
 			if item.pool.removeContainerFromIdle(item.cont) {

internal/test/main_test.go

@@ -2,13 +2,13 @@ package test
 
 import (
 	"context"
-	"errors"
 	"flag"
 	"fmt"
+	clientv3 "go.etcd.io/etcd/client/v3"
+	"go.etcd.io/etcd/server/v3/embed"
 	"log"
 	"net/http"
 	"os"
-	"os/exec"
 	"testing"
 	"time"
 
@@ -92,6 +92,55 @@ func TestMain(m *testing.M) {
 
 	// TODO: avoid full setup if testing.Short()
 
+	//
+	// START ETCD
+	//
+	// Create a temporary directory for etcd data
+	tempDir, err := os.MkdirTemp("", "etcd-data-*")
+	if err != nil {
+		log.Fatalf("Failed to create temp dir for etcd: %v", err)
+	}
+	// Schedule cleanup for the end of the test run
+	defer func(path string) {
+		err := os.RemoveAll(path)
+		if err != nil {
+			log.Printf("Failed to remove temp dir for etcd: %v", err)
+		}
+	}(tempDir)
+
+	// 1. Setup: Start an embedded etcd server
+	cfg := embed.NewConfig()
+	cfg.Dir = tempDir                      // Use the temporary directory
+	cfg.LogOutputs = []string{"/dev/null"} // Silence etcd output
+	etcd, err := embed.StartEtcd(cfg)
+	if err != nil {
+		log.Fatalf("Failed to start embedded etcd: %v", err)
+	}
+	defer etcd.Close()
+
+	select {
+	case <-etcd.Server.ReadyNotify():
+		// Silently continue
+	case <-time.After(60 * time.Second):
+		etcd.Server.Stop() // trigger a shutdown
+		log.Fatal("Embedded etcd server took too long to start")
+	}
+
+	// Create a client connected to the embedded server
+	etcdClient, err := clientv3.New(clientv3.Config{
+		Endpoints:   []string{etcd.Clients[0].Addr().String()},
+		DialTimeout: 5 * time.Second,
+	})
+	if err != nil {
+		log.Fatalf("Failed to create etcd client: %v", err)
+	}
+	defer func(etcdClient *clientv3.Client) {
+		err := etcdClient.Close()
+		if err != nil {
+			log.Printf("Failed to close etcd client: %v", err)
+		}
+	}(etcdClient)
+
 	echoServer, ok := setupServerledge(outboundIp.String())
 	if ok != nil {
 		fmt.Printf("failed to initialize serverledgde: %v\n", ok)
@@ -125,32 +174,9 @@ func waitForServerReady() {
 	log.Fatal("Server not ready after timeout")
 }
 
-// startReliably can start the containers, or restart them if needed
-func startReliably(startScript string) error {
-	// make sure etcd is not already running, this will cause issues. Also clean etcd status for clean start
-	cmd1 := exec.CommandContext(context.Background(), getShell(), "../../scripts/stop-etcd"+getShellExt())
-	if err := cmd1.Run(); err != nil {
-		// If the container doesn't exist, `docker stop` and `docker rm` will fail.
-		// We can safely ignore this error and proceed.
-		var exitError *exec.ExitError
-		if errors.As(err, &exitError) {
-			// 1 indicates that the container does not exist.
-			if exitError.ExitCode() != 1 {
-				log.Printf("failed to stop etcd: %v", err)
-			}
-		}
-	}
-
-	cmd := exec.CommandContext(context.Background(), getShell(), startScript)
-	err := cmd.Run()
-	if err != nil {
-		log.Fatalf("failed to start (%s): %v", startScript, err)
-	}
-	return err
-}
-
 // run the bash script to initialize serverledge
 func setupServerledge(outboundIp string) (*echo.Echo, error) {
+
 	echoServer := testStartServerledge(false, outboundIp)
 	return echoServer, nil
 }