small fixes and deploy event streaming

2024-12-10 02:56:44 -06:00
parent 6c035fc391
commit e46bb05b39
10 changed files with 671 additions and 205 deletions
--- a/server/deploy.go
+++ b/server/deploy.go
@@ -1,13 +1,17 @@
 package server

 import (
+	"bufio"
+	"context"
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"io"
 	"log"
 	"mime/multipart"
 	"net/http"
 	"os/exec"
+	"sync"

 	"github.com/juls0730/flux/pkg"
 )
@@ -25,7 +29,59 @@ type DeployResponse struct {
 	App App `json:"app"`
 }

+type DeploymentLock struct {
+	mu       sync.Mutex
+	deployed map[string]context.CancelFunc
+}
+
+func NewDeploymentLock() *DeploymentLock {
+	return &DeploymentLock{
+		deployed: make(map[string]context.CancelFunc),
+	}
+}
+
+func (dt *DeploymentLock) StartDeployment(appName string, ctx context.Context) (context.Context, error) {
+	dt.mu.Lock()
+	defer dt.mu.Unlock()
+
+	// Check if the app is already being deployed
+	if _, exists := dt.deployed[appName]; exists {
+		return nil, fmt.Errorf("app %s is already being deployed", appName)
+	}
+
+	// Create a context that can be cancelled
+	ctx, cancel := context.WithCancel(ctx)
+
+	// Store the cancel function
+	dt.deployed[appName] = cancel
+
+	return ctx, nil
+}
+
+func (dt *DeploymentLock) CompleteDeployment(appName string) {
+	dt.mu.Lock()
+	defer dt.mu.Unlock()
+
+	// Remove the app from deployed tracking
+	if cancel, exists := dt.deployed[appName]; exists {
+		// Cancel the context
+		cancel()
+		// Remove from map
+		delete(dt.deployed, appName)
+	}
+}
+
+var deploymentLock = NewDeploymentLock()
+
 func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
+	if Flux.appManager == nil {
+		panic("App manager is nil")
+	}
+
+	w.Header().Set("Content-Type", "test/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+
 	err := r.ParseMultipartForm(10 << 30) // 10 GiB
 	if err != nil {
 		log.Printf("Failed to parse multipart form: %v\n", err)
@@ -33,7 +89,6 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	// bind to DeployRequest struct
 	var deployRequest DeployRequest
 	deployRequest.Config, _, err = r.FormFile("config")
 	if err != nil {
@@ -42,21 +97,81 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	defer deployRequest.Config.Close()

+	var projectConfig pkg.ProjectConfig
+	if err := json.NewDecoder(deployRequest.Config).Decode(&projectConfig); err != nil {
+		log.Printf("Failed to decode config: %v\n", err)
+
+		http.Error(w, "Invalid flux.json", http.StatusBadRequest)
+		return
+	}
+
+	ctx, err := deploymentLock.StartDeployment(projectConfig.Name, r.Context())
+	if err != nil {
+		// This will happen if the app is already being deployed
+		http.Error(w, err.Error(), http.StatusConflict)
+		return
+	}
+
+	defer deploymentLock.CompleteDeployment(projectConfig.Name)
+
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
+		return
+	}
+
+	eventChannel := make(chan pkg.DeploymentEvent, 10)
+	var wg sync.WaitGroup
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		for {
+			select {
+			case event, ok := <-eventChannel:
+				if !ok {
+					return
+				}
+
+				eventJSON, err := json.Marshal(event)
+				if err != nil {
+					fmt.Fprintf(w, "data: %s\n\n", err.Error())
+					flusher.Flush()
+					return
+				}
+
+				fmt.Fprintf(w, "data: %s\n\n", eventJSON)
+				flusher.Flush()
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	eventChannel <- pkg.DeploymentEvent{
+		Stage:   "start",
+		Message: "Uploading code",
+	}
+
 	deployRequest.Code, _, err = r.FormFile("code")
 	if err != nil {
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: "No code archive found",
+			Error:   err.Error(),
+		}
 		http.Error(w, "No code archive found", http.StatusBadRequest)
 		return
 	}
 	defer deployRequest.Code.Close()

-	var projectConfig pkg.ProjectConfig
-	if err := json.NewDecoder(deployRequest.Config).Decode(&projectConfig); err != nil {
-		log.Printf("Failed to decode config: %v\n", err)
-		http.Error(w, "Invalid flux.json", http.StatusBadRequest)
-		return
-	}
-
 	if projectConfig.Name == "" || projectConfig.Url == "" || projectConfig.Port == 0 {
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: "Invalid flux.json, a name, url, and port must be specified",
+			Error:   "Invalid flux.json, a name, url, and port must be specified",
+		}
 		http.Error(w, "Invalid flux.json, a name, url, and port must be specified", http.StatusBadRequest)
 		return
 	}
@@ -66,58 +181,198 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
 	projectPath, err := s.UploadAppCode(deployRequest.Code, projectConfig)
 	if err != nil {
 		log.Printf("Failed to upload code: %v\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: "Failed to upload code",
+			Error:   err.Error(),
+		}
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

+	streamPipe := func(pipe io.ReadCloser) {
+		scanner := bufio.NewScanner(pipe)
+		for scanner.Scan() {
+			line := scanner.Text()
+			eventChannel <- pkg.DeploymentEvent{
+				Stage:   "cmd_output",
+				Message: fmt.Sprintf("%s", line),
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			eventChannel <- pkg.DeploymentEvent{
+				Stage:   "error",
+				Message: fmt.Sprintf("Failed to read pipe: %s", err),
+			}
+			log.Printf("Error reading pipe: %s\n", err)
+		}
+	}
+
 	log.Printf("Preparing project %s...\n", projectConfig.Name)
+	eventChannel <- pkg.DeploymentEvent{
+		Stage:   "preparing",
+		Message: "Preparing project",
+	}
+
 	prepareCmd := exec.Command("go", "generate")
 	prepareCmd.Dir = projectPath
+	cmdOut, err := prepareCmd.StdoutPipe()
+	if err != nil {
+		log.Printf("Failed to get stdout pipe: %v\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to get stdout pipe: %s", err),
+			Error:   err.Error(),
+		}
+
+		http.Error(w, fmt.Sprintf("Failed to get stdout pipe: %s", err), http.StatusInternalServerError)
+		return
+	}
+	cmdErr, err := prepareCmd.StderrPipe()
+	if err != nil {
+		log.Printf("Failed to get stderr pipe: %v\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to get stderr pipe: %s", err),
+			Error:   err.Error(),
+		}
+
+		http.Error(w, fmt.Sprintf("Failed to get stderr pipe: %s", err), http.StatusInternalServerError)
+		return
+	}
+
+	go streamPipe(cmdOut)
+	go streamPipe(cmdErr)
+
 	err = prepareCmd.Run()
 	if err != nil {
 		log.Printf("Failed to prepare project: %s\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to prepare project: %s", err),
+			Error:   err.Error(),
+		}
+
 		http.Error(w, fmt.Sprintf("Failed to prepare project: %s", err), http.StatusInternalServerError)
 		return
 	}
+	cmdOut.Close()
+	cmdErr.Close()
+
+	eventChannel <- pkg.DeploymentEvent{
+		Stage:   "building",
+		Message: "Building project image",
+	}

 	log.Printf("Building image for project %s...\n", projectConfig.Name)
 	imageName := fmt.Sprintf("flux_%s-image", projectConfig.Name)
 	buildCmd := exec.Command("pack", "build", imageName, "--builder", s.config.Builder)
 	buildCmd.Dir = projectPath
-	err = buildCmd.Run()
+	cmdOut, err = buildCmd.StdoutPipe()
 	if err != nil {
-		log.Printf("Failed to build image: %s\n", err)
-		http.Error(w, fmt.Sprintf("Failed to build image: %s", err), http.StatusInternalServerError)
+		log.Printf("Failed to get stdout pipe: %v\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to get stdout pipe: %s", err),
+			Error:   err.Error(),
+		}
+
+		http.Error(w, fmt.Sprintf("Failed to get stdout pipe: %s", err), http.StatusInternalServerError)
+		return
+	}
+	cmdErr, err = buildCmd.StderrPipe()
+	if err != nil {
+		log.Printf("Failed to get stderr pipe: %v\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to get stderr pipe: %s", err),
+			Error:   err.Error(),
+		}
+
+		http.Error(w, fmt.Sprintf("Failed to get stderr pipe: %s", err), http.StatusInternalServerError)
 		return
 	}

-	if Flux.appManager == nil {
-		panic("App manager is nil")
+	go streamPipe(cmdOut)
+	go streamPipe(cmdErr)
+
+	err = buildCmd.Run()
+	if err != nil {
+		log.Printf("Failed to build image: %s\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to build image: %s", err),
+			Error:   err.Error(),
+		}
+
+		http.Error(w, fmt.Sprintf("Failed to build image: %s", err), http.StatusInternalServerError)
+		return
 	}
+	cmdOut.Close()
+	cmdErr.Close()

 	app := Flux.appManager.GetApp(projectConfig.Name)

+	eventChannel <- pkg.DeploymentEvent{
+		Stage:   "creating",
+		Message: "Creating deployment",
+	}
+
 	if app == nil {
-		app, err = CreateApp(r.Context(), imageName, projectPath, projectConfig)
+		app, err = CreateApp(ctx, imageName, projectPath, projectConfig)
 		if err != nil {
 			log.Printf("Failed to create app: %v", err)
+			eventChannel <- pkg.DeploymentEvent{
+				Stage:   "error",
+				Message: fmt.Sprintf("Failed to create app: %s", err),
+				Error:   err.Error(),
+			}
+
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 	} else {
-		err = app.Upgrade(r.Context(), projectConfig, imageName, projectPath)
+		err = app.Upgrade(ctx, projectConfig, imageName, projectPath)
 		if err != nil {
-			log.Printf("Failed to upgrade deployment: %v", err)
+			log.Printf("Failed to upgrade app: %v", err)
+			eventChannel <- pkg.DeploymentEvent{
+				Stage:   "error",
+				Message: fmt.Sprintf("Failed to upgrade app: %s", err),
+				Error:   err.Error(),
+			}
+
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 	}

-	log.Printf("App %s deployed successfully!\n", app.Name)
-
-	json.NewEncoder(w).Encode(DeployResponse{
+	responseJSON, err := json.Marshal(DeployResponse{
 		App: *app,
 	})
+	if err != nil {
+		log.Printf("Failed to marshal deploy response: %v\n", err)
+		eventChannel <- pkg.DeploymentEvent{
+			Stage:   "error",
+			Message: fmt.Sprintf("Failed to marshal deploy response: %s", err),
+			Error:   err.Error(),
+		}
+
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	eventChannel <- pkg.DeploymentEvent{
+		Stage:   "complete",
+		Message: fmt.Sprintf("%s", responseJSON),
+	}
+
+	log.Printf("App %s deployed successfully!\n", app.Name)
+
+	close(eventChannel)
+
+	// make sure all the events are flushed
+	wg.Wait()
 }

 func (s *FluxServer) StartDeployHandler(w http.ResponseWriter, r *http.Request) {