fix: make file update atomic, wait for /start (#329)

Signed-off-by: Todd Baert <todd.baert@dynatrace.com>

Author: toddbaert

.gitignore

@@ -1,3 +1,5 @@
 .idea
 node_modules
 bin/
+# dynamically generated flags
+flags/allFlags.json

launchpad/pkg/file.go

@@ -86,7 +86,8 @@ func ToggleChangingFlag() (string, error) {
 
 	// Write the updated JSON back to the file
 	fileLock.Lock()
-	if err := os.WriteFile(configFile, updatedData, 0644); err != nil {
+	if err := atomicWriteFile(configFile, updatedData); err != nil {
+		fileLock.Unlock()
 		return "", err
 	}
 	fileLock.Unlock()

launchpad/pkg/flagd.go

@@ -1,14 +1,12 @@
 package flagd
 
 import (
-	"bufio"
 	"context"
 	"errors"
 	"fmt"
-	"io"
+	"net/http"
 	"os"
 	"os/exec"
-	"strings"
 	"sync"
 	"time"
 )
@@ -95,39 +93,36 @@ func StartFlagd(config string) error {
 	configPath := fmt.Sprintf("./configs/%s.json", config)
 
 	flagdCmd = exec.Command("./flagd", "start", "--config", configPath)
-
-	stdout, err := flagdCmd.StdoutPipe()
-	if err != nil {
-		return fmt.Errorf("failed to capture stdout: %v", err)
-	}
-	stderr, err := flagdCmd.StderrPipe()
-	if err != nil {
-		return fmt.Errorf("failed to capture stderr: %v", err)
-	}
+	flagdCmd.Stdout = os.Stdout
+	flagdCmd.Stderr = os.Stderr
 
 	if err := flagdCmd.Start(); err != nil {
+		flagdLock.Unlock()
 		return fmt.Errorf("failed to start flagd: %v", err)
 	}
-
 	flagdLock.Unlock()
-	ready := make(chan bool)
 
-	go monitorOutput(stdout, ready, "stdout")
-	go monitorOutput(stderr, ready, "stderr")
+	// Poll health endpoint until ready
+	client := &http.Client{Timeout: 500 * time.Millisecond}
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+	timeout := time.After(10 * time.Second)
 
-	select {
-	case success := <-ready:
-		if success {
-			fmt.Println("flagd started successfully.")
-			return nil
-		}
-		return fmt.Errorf("flagd did not start correctly")
-	case <-time.After(10 * time.Second):
-		err := StopFlagd()
-		if err != nil {
-			fmt.Println("could not stop flagd", err)
+	for {
+		select {
+		case <-timeout:
+			_ = StopFlagd()
+			return fmt.Errorf("flagd health check timed out")
+		case <-ticker.C:
+			resp, err := client.Get("http://localhost:8014/readyz")
+			if err == nil {
+				resp.Body.Close()
+				if resp.StatusCode == http.StatusOK {
+					fmt.Println("flagd started successfully.")
+					return nil
+				}
+			}
 		}
-		return fmt.Errorf("flagd start timeout exceeded")
 	}
 }
 
@@ -174,23 +169,3 @@ func stopFlagDWithoutLock() error {
 	}
 	return nil
 }
-
-func monitorOutput(pipe io.ReadCloser, ready chan bool, stream string) {
-	scanner := bufio.NewScanner(pipe)
-	//adjust the capacity to your need (max characters in line)
-	const maxCapacity = 512 * 1024
-	buf := make([]byte, maxCapacity)
-	scanner.Buffer(buf, maxCapacity)
-	started := false
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		fmt.Println("[flagd ", stream, "]:", line)
-		if ready != nil && !started && strings.Contains(line, "listening at") {
-			ready <- true
-			close(ready)
-			fmt.Println("flagd started properly found logline with 'listening at'")
-			started = true
-		}
-	}
-}

launchpad/pkg/json.go

@@ -10,6 +10,33 @@ import (
 	"sync"
 )
 
+// writes a file atomically using mv
+func atomicWriteFile(filename string, data []byte) error {
+	tmpFile, err := os.CreateTemp(filepath.Dir(filename), ".tmp-*")
+	if err != nil {
+		return err
+	}
+	tmpName := tmpFile.Name()
+
+	if _, err := tmpFile.Write(data); err != nil {
+		tmpFile.Close()
+		os.Remove(tmpName)
+		return err
+	}
+
+	if err := tmpFile.Close(); err != nil {
+		os.Remove(tmpName)
+		return err
+	}
+
+	if err := os.Rename(tmpName, filename); err != nil {
+		os.Remove(tmpName)
+		return err
+	}
+
+	return nil
+}
+
 var (
 	mu         sync.Mutex
 	InputDir   = "./rawflags"
@@ -54,7 +81,7 @@ func CombineJSONFiles(inputDir string) error {
 		return fmt.Errorf("failed to serialize combined JSON: %v", err)
 	}
 
-	return ioutil.WriteFile(OutputFile, combinedContent, 0644)
+	return atomicWriteFile(OutputFile, combinedContent)
 }
 
 func deepMerge(dst, src map[string]interface{}) map[string]interface{} {