Massive architectural rework

This commit massively overhauls the project's structure to simplify development. Most parts are now correctly compartmentalized and dependencies are passed in a sane way rather than global variables galore xd.
2025-05-02 12:15:40 -05:00
parent f4bf2ff5a1
commit c891c24843
50 changed files with 2684 additions and 2410 deletions
--- a/cmd/cli/commands/deploy.go
+++ b/cmd/cli/commands/deploy.go
@@ -0,0 +1,372 @@
+package commands
+
+import (
+	"archive/tar"
+	"bufio"
+	"bytes"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/briandowns/spinner"
+	"github.com/google/uuid"
+	"github.com/joho/godotenv"
+	util "github.com/juls0730/flux/internal/util/cli"
+	"github.com/juls0730/flux/pkg"
+	"github.com/juls0730/flux/pkg/API"
+)
+
+func matchesIgnorePattern(path string, info os.FileInfo, patterns []string) bool {
+	normalizedPath := filepath.ToSlash(path)
+	normalizedPath = strings.TrimPrefix(normalizedPath, "./")
+
+	for _, pattern := range patterns {
+		pattern = strings.TrimSpace(pattern)
+		if pattern == "" || strings.HasPrefix(pattern, "#") {
+			continue
+		}
+
+		regexPattern := convertGitignorePatternToRegex(pattern)
+
+		matched, err := regexp.MatchString(regexPattern, normalizedPath)
+		if err == nil && matched {
+			if strings.HasSuffix(pattern, "/") && info.IsDir() {
+				return true
+			}
+			if !info.IsDir() {
+				dir := filepath.Dir(normalizedPath)
+				for dir != "." && dir != "/" {
+					dirPattern := convertGitignorePatternToRegex(pattern)
+					if matched, _ := regexp.MatchString(dirPattern, filepath.ToSlash(dir)); matched {
+						return true
+					}
+					dir = filepath.Dir(dir)
+				}
+			}
+			return true
+		}
+	}
+	return false
+}
+
+func convertGitignorePatternToRegex(pattern string) string {
+	pattern = strings.TrimSuffix(pattern, "/")
+	pattern = regexp.QuoteMeta(pattern)
+	pattern = strings.ReplaceAll(pattern, "\\*\\*", ".*")
+	pattern = strings.ReplaceAll(pattern, "\\*", "[^/]*")
+	pattern = strings.ReplaceAll(pattern, "\\?", ".")
+	pattern = "(^|.*/)" + pattern + "(/.*)?$"
+
+	return pattern
+}
+
+func compressDirectory(compressionLevel int) ([]byte, error) {
+	var buf bytes.Buffer
+	var err error
+
+	var ignoredFiles []string
+	fluxIgnore, err := os.Open(".fluxignore")
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if fluxIgnore != nil {
+		defer fluxIgnore.Close()
+
+		scanner := bufio.NewScanner(fluxIgnore)
+		for scanner.Scan() {
+			ignoredFiles = append(ignoredFiles, scanner.Text())
+		}
+	}
+
+	var gzWriter *gzip.Writer
+	if compressionLevel > 0 {
+		gzWriter, err = gzip.NewWriterLevel(&buf, compressionLevel)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var tarWriter *tar.Writer
+	if gzWriter != nil {
+		tarWriter = tar.NewWriter(gzWriter)
+	} else {
+		tarWriter = tar.NewWriter(&buf)
+	}
+
+	err = filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if path == "flux.json" || info.IsDir() || matchesIgnorePattern(path, info, ignoredFiles) {
+			return nil
+		}
+
+		header, err := tar.FileInfoHeader(info, "")
+		if err != nil {
+			return err
+		}
+		header.Name = path
+
+		if err = tarWriter.WriteHeader(header); err != nil {
+			return err
+		}
+
+		if !info.IsDir() {
+			file, err := os.Open(path)
+			if err != nil {
+				return err
+			}
+			defer file.Close()
+
+			if _, err = io.Copy(tarWriter, file); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if err = tarWriter.Close(); err != nil {
+		return nil, err
+	}
+
+	if gzWriter != nil {
+		if err = gzWriter.Close(); err != nil {
+			return nil, err
+		}
+	}
+
+	return buf.Bytes(), nil
+}
+
+func preprocessEnvFile(envFile string, target *[]string) error {
+	envBytes, err := os.Open(envFile)
+	if err != nil {
+		return fmt.Errorf("failed to open env file: %v", err)
+	}
+	defer envBytes.Close()
+
+	envVars, err := godotenv.Parse(envBytes)
+	if err != nil {
+		return fmt.Errorf("failed to parse env file: %v", err)
+	}
+
+	for key, value := range envVars {
+		*target = append(*target, fmt.Sprintf("%s=%s", key, value))
+	}
+
+	return nil
+}
+
+func DeployCommand(ctx CommandCtx, args []string) error {
+	if _, err := os.Stat("flux.json"); err != nil {
+		return fmt.Errorf("no flux.json found, please run flux init first")
+	}
+
+	spinnerWriter := util.NewCustomSpinnerWriter()
+
+	loadingSpinner := spinner.New(spinner.CharSets[14], 100*time.Millisecond, spinner.WithWriter(spinnerWriter))
+	defer func() {
+		if loadingSpinner.Active() {
+			loadingSpinner.Stop()
+		}
+	}()
+
+	signalChannel := make(chan os.Signal, 1)
+	signal.Notify(signalChannel, os.Interrupt)
+	go func() {
+		<-signalChannel
+		if loadingSpinner.Active() {
+			loadingSpinner.Stop()
+		}
+
+		os.Exit(0)
+	}()
+
+	loadingSpinner.Suffix = " Deploying"
+	loadingSpinner.Start()
+
+	buf, err := compressDirectory(ctx.Info.CompressionLevel)
+	if err != nil {
+		return fmt.Errorf("failed to compress directory: %v", err)
+	}
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	if _, err := os.Stat(".fluxid"); err == nil {
+		idPart, err := writer.CreateFormField("id")
+		if err != nil {
+			return fmt.Errorf("failed to create id part: %v", err)
+		}
+
+		idFile, err := os.Open(".fluxid")
+		if err != nil {
+			return fmt.Errorf("failed to open .fluxid: %v", err)
+		}
+		defer idFile.Close()
+
+		var idBytes []byte
+		if idBytes, err = io.ReadAll(idFile); err != nil {
+			return fmt.Errorf("failed to read .fluxid: %v", err)
+		}
+
+		if _, err := uuid.Parse(string(idBytes)); err != nil {
+			return fmt.Errorf(".fluxid does not contain a valid uuid")
+		}
+
+		idPart.Write(idBytes)
+	}
+
+	configPart, err := writer.CreateFormField("config")
+
+	if err != nil {
+		return fmt.Errorf("failed to create config part: %v", err)
+	}
+
+	type FluxContainers struct {
+		pkg.Container
+		EnvFile string `json:"env_file,omitempty"`
+	}
+
+	type FluxConfig struct {
+		pkg.ProjectConfig
+		EnvFile    string           `json:"env_file,omitempty"`
+		Containers []FluxContainers `json:"containers,omitempty"`
+	}
+
+	fluxConfigFile, err := os.Open("flux.json")
+	if err != nil {
+		return fmt.Errorf("failed to open flux.json: %v", err)
+	}
+	defer fluxConfigFile.Close()
+
+	// Read the entire JSON file into a byte slice
+	byteValue, err := io.ReadAll(fluxConfigFile)
+	if err != nil {
+		return fmt.Errorf("failed to read flux.json: %v", err)
+	}
+
+	var fluxConfig FluxConfig
+	err = json.Unmarshal(byteValue, &fluxConfig)
+	if err != nil {
+		return fmt.Errorf("failed to unmarshal flux.json: %v", err)
+	}
+
+	if fluxConfig.EnvFile != "" {
+		if err := preprocessEnvFile(fluxConfig.EnvFile, &fluxConfig.Environment); err != nil {
+			return fmt.Errorf("failed to preprocess env file: %v", err)
+		}
+	}
+
+	for _, container := range fluxConfig.Containers {
+		if container.EnvFile != "" {
+			if err := preprocessEnvFile(container.EnvFile, &container.Environment); err != nil {
+				return fmt.Errorf("failed to preprocess env file: %v", err)
+			}
+		}
+	}
+
+	// write the pre-processed flux.json to the config part
+	if err := json.NewEncoder(configPart).Encode(fluxConfig); err != nil {
+		return fmt.Errorf("failed to encode flux.json: %v", err)
+	}
+
+	var codeFileName string
+	if ctx.Info.CompressionLevel > 0 {
+		codeFileName = "code.tar.gz"
+	} else {
+		codeFileName = "code.tar"
+	}
+
+	codePart, err := writer.CreateFormFile("code", codeFileName)
+	if err != nil {
+		return fmt.Errorf("failed to create code part: %v", err)
+	}
+
+	if _, err := codePart.Write(buf); err != nil {
+		return fmt.Errorf("failed to write code part: %v", err)
+	}
+
+	if err := writer.Close(); err != nil {
+		return fmt.Errorf("failed to close writer: %v", err)
+	}
+
+	req, err := http.NewRequest("POST", ctx.Config.DaemonURL+"/deploy", body)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	if err != nil {
+		return fmt.Errorf("failed to create request: %v", err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	customWriter := util.NewCustomStdout(spinnerWriter)
+
+	scanner := bufio.NewScanner(resp.Body)
+	var event string
+	var data API.DeploymentEvent
+	var line string
+	for scanner.Scan() {
+		line = scanner.Text()
+		if strings.HasPrefix(line, "data: ") {
+			if err := json.Unmarshal([]byte(line[6:]), &data); err != nil {
+				return fmt.Errorf("failed to parse deployment event: %v", err)
+			}
+
+			switch event {
+			case "complete":
+				loadingSpinner.Stop()
+				fmt.Printf("App %s deployed successfully!\n", data.Message.(map[string]any)["name"])
+				if _, err := os.Stat(".fluxid"); os.IsNotExist(err) {
+					idFile, err := os.Create(".fluxid")
+					if err != nil {
+						return fmt.Errorf("failed to create .fluxid: %v", err)
+					}
+					defer idFile.Close()
+
+					id := data.Message.(map[string]any)["id"].(string)
+					if _, err := idFile.Write([]byte(id)); err != nil {
+						return fmt.Errorf("failed to write .fluxid: %v", err)
+					}
+				}
+				return nil
+			case "cmd_output":
+				customWriter.Printf("... %s\n", data.Message)
+			case "error":
+				loadingSpinner.Stop()
+				return fmt.Errorf("deployment failed: %s", data.Message)
+			default:
+				customWriter.Printf("%s\n", data.Message)
+			}
+			event = ""
+		} else if strings.HasPrefix(line, "event: ") {
+			event = strings.TrimPrefix(line, "event: ")
+		}
+	}
+
+	// the stream closed, but we didnt get a "complete" event
+	line = strings.TrimSuffix(line, "\n")
+	return fmt.Errorf("deploy failed: %s", line)
+}