seems e2e tests are working

Author: evgeniy-scherbina

cli/cli.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"log/slog"
 	"os"
+	"os/exec"
 	"os/signal"
 	"path/filepath"
 	"strings"
@@ -110,8 +111,21 @@ func Run(ctx context.Context, config Config, args []string) error {
 		bin := args[0]
 		args = args[1:]
 		env := os.Environ()
-		log.Printf("bin: %v, args: %v\n", bin, args)
-		log.Printf("env: %v\n", os.Environ())
+
+		cmd := exec.Command(bin, args...)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err = cmd.Run()
+		if err != nil {
+			log.Printf("failed to run %s: %v, output: %s", bin, err, "output")
+			return err
+		}
+		log.Printf("successfully run %s: %s", bin, "output")
+		return nil
+
+		//log.Printf("bin: %v, args: %v\n", bin, args)
+		//log.Printf("env: %v\n", os.Environ())
 		// syscall.Exec replaces the current process image
 		// with the new program, so nothing after this call runs.
 		if err := syscall.Exec(bin, args, env); err != nil {
@@ -239,6 +253,7 @@ func Run(ctx context.Context, config Config, args []string) error {
 			logger.Error("configuration failed", "error", err)
 		}
 
+		logger.Debug("waiting on a child process to finish")
 		err = cmd.Wait()
 		if err != nil {
 			logger.Error("Command execution failed(Wait)", "error", err)

e2e_tests/boundary_integration_test.go

@@ -63,19 +63,54 @@ func getNamespaceName(t *testing.T) string {
 	return namespaces[0]
 }
 
+//func getChildProcessPID(t *testing.T) int {
+//	// Option 1: Look for processes with CHILD=true
+//	cmd := exec.Command("pgrep", "-f", "CHILD=true")
+//	output, err := cmd.CombinedOutput()
+//	require.NoError(t, err, "output: %v", output)
+//
+//	pidStr := strings.TrimSpace(string(output))
+//	pid, err := strconv.Atoi(pidStr)
+//	require.NoError(t, err)
+//	return pid
+//
+//	// Option 2: Use the boundary process's child PID
+//	// This would require modifying boundary to expose the child PID
+//}
+
+//func getBoundaryProcessPID(t *testing.T) int {
+//	cmd := exec.Command("pgrep", "-f", "boundary-test")
+//	output, err := cmd.Output()
+//	require.NoError(t, err)
+//
+//	pidStr := strings.TrimSpace(string(output))
+//	pid, err := strconv.Atoi(pidStr)
+//	require.NoError(t, err)
+//	return pid
+//}
+//
+//func getChildProcessPID(t *testing.T) int {
+//	boundaryPID := getBoundaryProcessPID(t)
+//
+//	cmd := exec.Command("pgrep", "-P", fmt.Sprintf("%d", boundaryPID))
+//	output, err := cmd.Output()
+//	require.NoError(t, err)
+//
+//	pidStr := strings.TrimSpace(string(output))
+//	pid, err := strconv.Atoi(pidStr)
+//	require.NoError(t, err)
+//	return pid
+//}
+
 func getChildProcessPID(t *testing.T) int {
-	// Option 1: Look for processes with CHILD=true
-	cmd := exec.Command("pgrep", "-f", "CHILD=true")
-	output, err := cmd.CombinedOutput()
-	require.NoError(t, err, "output: %v", output)
+	cmd := exec.Command("pgrep", "-f", "boundary-test", "-n")
+	output, err := cmd.Output()
+	require.NoError(t, err)
 
 	pidStr := strings.TrimSpace(string(output))
 	pid, err := strconv.Atoi(pidStr)
 	require.NoError(t, err)
 	return pid
-
-	// Option 2: Use the boundary process's child PID
-	// This would require modifying boundary to expose the child PID
 }
 
 func TestBoundaryIntegration(t *testing.T) {
@@ -89,34 +124,37 @@ func TestBoundaryIntegration(t *testing.T) {
 	require.NoError(t, err, "Failed to build boundary binary")
 
 	// Create context for boundary process
-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 1500*time.Second)
 	defer cancel()
 
 	// Start boundary process with sudo
 	boundaryCmd := exec.CommandContext(ctx, "/tmp/boundary-test",
 		"--allow", "dev.coder.com",
 		"--allow", "jsonplaceholder.typicode.com",
 		"--log-level", "debug",
-		"--", "/bin/bash")
-	//"--", "/bin/bash", "-c", "/usr/bin/sleep 10 && /usr/bin/echo 'Test completed'")
+		//"--", "/bin/bash")
+		"--", "/bin/bash", "-c", "/usr/bin/sleep 45 && /usr/bin/echo 'Test completed'")
 
-	// Suppress output to prevent terminal corruption
-	boundaryCmd.Stdout = os.Stdout // Let it go to /dev/null
+	boundaryCmd.Stdin = os.Stdin
+	boundaryCmd.Stdout = os.Stdout
 	boundaryCmd.Stderr = os.Stderr
 
 	// Start the process
 	err = boundaryCmd.Start()
 	require.NoError(t, err, "Failed to start boundary process")
 
 	// Give boundary time to start
-	time.Sleep(200 * time.Second)
+	time.Sleep(2 * time.Second)
 
 	// Get the namespace name that boundary created
 	//namespaceName := getNamespaceName(t)
 
 	pidInt := getChildProcessPID(t)
 	pid := fmt.Sprintf("%v", pidInt)
 
+	fmt.Printf("pidInt: %v\n", pidInt)
+	//time.Sleep(200 * time.Second)
+
 	// Test HTTP request through boundary (from inside the jail)
 	t.Run("HTTPRequestThroughBoundary", func(t *testing.T) {
 		// Run curl directly in the namespace using ip netns exec