something

internal/api/metadata.go

@@ -2,8 +2,6 @@ package api
 
 import (
 	"archive/tar"
-	"bufio"
-	"bytes"
 	"database/sql"
 	_ "embed"
 	"encoding/json"
@@ -13,10 +11,10 @@ import (
 	"log"
 	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 
+	"jiggablend/pkg/executils"
 	"jiggablend/pkg/scripts"
 	"jiggablend/pkg/types"
 )
@@ -44,7 +42,9 @@ func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
 
 	// Verify job exists
 	var jobUserID int64
-	err = s.db.QueryRow("SELECT user_id FROM jobs WHERE id = ?", jobID).Scan(&jobUserID)
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.QueryRow("SELECT user_id FROM jobs WHERE id = ?", jobID).Scan(&jobUserID)
+	})
 	if err == sql.ErrNoRows {
 		s.respondError(w, http.StatusNotFound, "Job not found")
 		return
@@ -57,30 +57,36 @@ func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
 	// Find the metadata extraction task for this job
 	// First try to find task assigned to this runner, then fall back to any metadata task for this job
 	var taskID int64
-	err = s.db.QueryRow(
+	err = s.db.With(func(conn *sql.DB) error {
+		err := conn.QueryRow(
 		`SELECT id FROM tasks WHERE job_id = ? AND task_type = ? AND runner_id = ?`,
 		jobID, types.TaskTypeMetadata, runnerID,
 	).Scan(&taskID)
 	if err == sql.ErrNoRows {
 		// Fall back to any metadata task for this job (in case assignment changed)
-		err = s.db.QueryRow(
+			err = conn.QueryRow(
 			`SELECT id FROM tasks WHERE job_id = ? AND task_type = ? ORDER BY created_at DESC LIMIT 1`,
 			jobID, types.TaskTypeMetadata,
 		).Scan(&taskID)
 		if err == sql.ErrNoRows {
+				return fmt.Errorf("metadata extraction task not found")
+			}
+			if err != nil {
+				return err
+			}
+			// Update the task to be assigned to this runner if it wasn't already
+			conn.Exec(
+				`UPDATE tasks SET runner_id = ? WHERE id = ? AND runner_id IS NULL`,
+				runnerID, taskID,
+			)
+		}
+		return err
+	})
+	if err != nil {
+		if err.Error() == "metadata extraction task not found" {
 			s.respondError(w, http.StatusNotFound, "Metadata extraction task not found")
 			return
 		}
-		if err != nil {
-			s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to find task: %v", err))
-			return
-		}
-		// Update the task to be assigned to this runner if it wasn't already
-		s.db.Exec(
-			`UPDATE tasks SET runner_id = ? WHERE id = ? AND runner_id IS NULL`,
-			runnerID, taskID,
-		)
-	} else if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to find task: %v", err))
 		return
 	}
@@ -93,20 +99,27 @@ func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Update job with metadata
-	_, err = s.db.Exec(
+	err = s.db.With(func(conn *sql.DB) error {
+		_, err := conn.Exec(
 		`UPDATE jobs SET blend_metadata = ? WHERE id = ?`,
 		string(metadataJSON), jobID,
 	)
+		return err
+	})
 	if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to update job metadata: %v", err))
 		return
 	}
 
 	// Mark task as completed
-	_, err = s.db.Exec(
-		`UPDATE tasks SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?`,
-		types.TaskStatusCompleted, taskID,
-	)
+	err = s.db.With(func(conn *sql.DB) error {
+		_, err := conn.Exec(`UPDATE tasks SET status = ? WHERE id = ?`, types.TaskStatusCompleted, taskID)
+		if err != nil {
+			return err
+		}
+		_, err = conn.Exec(`UPDATE tasks SET completed_at = CURRENT_TIMESTAMP WHERE id = ?`, taskID)
+		return err
+	})
 	if err != nil {
 		log.Printf("Failed to mark metadata task as completed: %v", err)
 	} else {
@@ -136,10 +149,12 @@ func (s *Server) handleGetJobMetadata(w http.ResponseWriter, r *http.Request) {
 	// Verify job belongs to user
 	var jobUserID int64
 	var blendMetadataJSON sql.NullString
-	err = s.db.QueryRow(
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.QueryRow(
 		`SELECT user_id, blend_metadata FROM jobs WHERE id = ?`,
 		jobID,
 	).Scan(&jobUserID, &blendMetadataJSON)
+	})
 	if err == sql.ErrNoRows {
 		s.respondError(w, http.StatusNotFound, "Job not found")
 		return
@@ -245,64 +260,23 @@ func (s *Server) extractMetadataFromContext(jobID int64) (*types.BlendMetadata,
 		return nil, fmt.Errorf("failed to get relative path for blend file: %w", err)
 	}
 
-	// Execute Blender with Python script
-	cmd := exec.Command("blender", "-b", blendFileRel, "--python", "extract_metadata.py")
-	cmd.Dir = tmpDir
+	// Execute Blender with Python script using executils
+	result, err := executils.RunCommand(
+		"blender",
+		[]string{"-b", blendFileRel, "--python", "extract_metadata.py"},
+		tmpDir,
+		nil, // inherit environment
+		jobID,
+		nil, // no process tracker needed for metadata extraction
+	)
 
-	// Capture stdout and stderr
-	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
-		return nil, fmt.Errorf("failed to create stdout pipe: %w", err)
-	}
-
-	stderrPipe, err := cmd.StderrPipe()
-	if err != nil {
-		return nil, fmt.Errorf("failed to create stderr pipe: %w", err)
-	}
-
-	// Buffer to collect stdout for JSON parsing
-	var stdoutBuffer bytes.Buffer
-
-	// Start the command
-	if err := cmd.Start(); err != nil {
-		return nil, fmt.Errorf("failed to start blender: %w", err)
-	}
-
-	// Stream stdout and collect for JSON parsing
-	stdoutDone := make(chan bool)
-	go func() {
-		defer close(stdoutDone)
-		scanner := bufio.NewScanner(stdoutPipe)
-		for scanner.Scan() {
-			line := scanner.Text()
-			stdoutBuffer.WriteString(line)
-			stdoutBuffer.WriteString("\n")
+		stderrOutput := ""
+		stdoutOutput := ""
+		if result != nil {
+			stderrOutput = strings.TrimSpace(result.Stderr)
+			stdoutOutput = strings.TrimSpace(result.Stdout)
 		}
-	}()
-
-	// Capture stderr for error reporting
-	var stderrBuffer bytes.Buffer
-	stderrDone := make(chan bool)
-	go func() {
-		defer close(stderrDone)
-		scanner := bufio.NewScanner(stderrPipe)
-		for scanner.Scan() {
-			line := scanner.Text()
-			stderrBuffer.WriteString(line)
-			stderrBuffer.WriteString("\n")
-		}
-	}()
-
-	// Wait for command to complete
-	err = cmd.Wait()
-
-	// Wait for streaming goroutines to finish
-	<-stdoutDone
-	<-stderrDone
-
-	if err != nil {
-		stderrOutput := strings.TrimSpace(stderrBuffer.String())
-		stdoutOutput := strings.TrimSpace(stdoutBuffer.String())
 		log.Printf("Blender metadata extraction failed for job %d:", jobID)
 		if stderrOutput != "" {
 			log.Printf("Blender stderr: %s", stderrOutput)
@@ -317,7 +291,7 @@ func (s *Server) extractMetadataFromContext(jobID int64) (*types.BlendMetadata,
 	}
 
 	// Parse output (metadata is printed to stdout)
-	metadataJSON := strings.TrimSpace(stdoutBuffer.String())
+	metadataJSON := strings.TrimSpace(result.Stdout)
 	// Extract JSON from output (Blender may print other stuff)
 	jsonStart := strings.Index(metadataJSON, "{")
 	jsonEnd := strings.LastIndex(metadataJSON, "}")