infctl-cli/app/k8s.go

package app

import (
	"bufio"
	"bytes"
	"fmt"
	"log/slog"
	"os/exec"
	"strings"
)

func k8sNamespaceExists(project string) error {

	commandString := "kubectl get ns " + project

	cmd := exec.Command("sh", "-c", commandString)
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	err := cmd.Run()
	if err != nil {

		if strings.Contains(stderr.String(), "not found") {
			err := k8sCreateNamespace(project)
			if err != nil {
				slog.Error(fmt.Sprintf("Failed to create namespace: %s", project))
				return fmt.Errorf("failed to create namespace: %w", err)
			}
			return nil
		} else {
			slog.Error(fmt.Sprintf("❌ Command failed with error: %v\n", err))
			slog.Debug(fmt.Sprintf("🐞 Stdout: %s\n", stdout.String()))
			slog.Debug(fmt.Sprintf("🐞 Stderr: %s\n", stderr.String()))
			return fmt.Errorf("failed to run kubectl command: %w", err)
		}
	}
	output := stdout.String()
	if !strings.Contains(output, project) {
		return fmt.Errorf("namespace %s does not exist", project)
	}
	slog.Info(fmt.Sprintf("k8sNamespaceExists nothing to do - project: %s eists ...", project))

	return nil
}

func k8sCreateNamespace(project string) error {
	slog.Info(fmt.Sprintf("in k8sCreateNamespace with project: %s", project))
	commandString := "kubectl create ns " + project
	cmd := exec.Command("sh", "-c", commandString)
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	err := cmd.Run()
	if err != nil {
		slog.Error(fmt.Sprintf("❌ Command failed with error: %v\n", err))
		slog.Debug(fmt.Sprintf("🐞 Stdout: %s\n", stdout.String()))
		slog.Debug(fmt.Sprintf("🐞 Stderr: %s\n", stderr.String()))
		return fmt.Errorf("failed to run kubectl command: %w", err)
	}
	output := stdout.String()
	if !strings.Contains(output, project) {
		return fmt.Errorf("failed to create namespace %s", project)
	}

	return nil
}

func RunCommand(command string) error {
	slog.Debug(fmt.Sprintf("🐞 Running command: %s", command))
	cmd := exec.Command("sh", "-c", command)

	var stdout, stderr bytes.Buffer

	// Get pipes for real-time reading
	stdoutPipe, err := cmd.StdoutPipe()
	if err != nil {
		return fmt.Errorf("failed to create stdout pipe: %w", err)
	}
	stderrPipe, err := cmd.StderrPipe()
	if err != nil {
		return fmt.Errorf("failed to create stderr pipe: %w", err)
	}

	// Start the command
	if err := cmd.Start(); err != nil {
		return fmt.Errorf("failed to start command: %w", err)
	}

	// Read stdout line by line and log through slog
	go func() {
		scanner := bufio.NewScanner(stdoutPipe)
		for scanner.Scan() {
			line := scanner.Text()
			stdout.WriteString(line + "\n")
			slog.Info(line)
		}
	}()

	// Read stderr line by line and log through slog
	go func() {
		scanner := bufio.NewScanner(stderrPipe)
		for scanner.Scan() {
			line := scanner.Text()
			stderr.WriteString(line + "\n")
			slog.Error(line)
		}
	}()

	// Wait for command to complete
	err = cmd.Wait()
	if err != nil {
		slog.Error(fmt.Sprintf("❌ Command failed with error: %v\n", err))
		slog.Debug(fmt.Sprintf("🐞 Stdout: %s\n", stdout.String()))
		slog.Debug(fmt.Sprintf("🐞 Stderr: %s\n", stderr.String()))
		return fmt.Errorf("failed to run script command: %w", err)
	}

	return nil
}