583 lines
16 KiB
Go
583 lines
16 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"fuego/internal/auth"
|
|
"fuego/pkg/types"
|
|
)
|
|
|
|
// handleListRunners lists all runners
|
|
func (s *Server) handleListRunners(w http.ResponseWriter, r *http.Request) {
|
|
_, err := getUserID(r)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusUnauthorized, err.Error())
|
|
return
|
|
}
|
|
|
|
rows, err := s.db.Query(
|
|
`SELECT id, name, hostname, ip_address, status, last_heartbeat, capabilities, created_at
|
|
FROM runners ORDER BY created_at DESC`,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query runners: %v", err))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
runners := []types.Runner{}
|
|
for rows.Next() {
|
|
var runner types.Runner
|
|
err := rows.Scan(
|
|
&runner.ID, &runner.Name, &runner.Hostname, &runner.IPAddress,
|
|
&runner.Status, &runner.LastHeartbeat, &runner.Capabilities, &runner.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to scan runner: %v", err))
|
|
return
|
|
}
|
|
runners = append(runners, runner)
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusOK, runners)
|
|
}
|
|
|
|
// runnerAuthMiddleware verifies runner requests using HMAC signatures
|
|
func (s *Server) runnerAuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
// Get runner ID from query string
|
|
runnerIDStr := r.URL.Query().Get("runner_id")
|
|
if runnerIDStr == "" {
|
|
s.respondError(w, http.StatusBadRequest, "runner_id required in query string")
|
|
return
|
|
}
|
|
|
|
var runnerID int64
|
|
_, err := fmt.Sscanf(runnerIDStr, "%d", &runnerID)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, "invalid runner_id")
|
|
return
|
|
}
|
|
|
|
// Get runner secret
|
|
runnerSecret, err := s.secrets.GetRunnerSecret(runnerID)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusUnauthorized, "runner not found or not verified")
|
|
return
|
|
}
|
|
|
|
// Verify request signature
|
|
valid, err := auth.VerifyRequest(r, runnerSecret, 5*time.Minute)
|
|
if err != nil || !valid {
|
|
s.respondError(w, http.StatusUnauthorized, "invalid signature")
|
|
return
|
|
}
|
|
|
|
// Add runner ID to context
|
|
ctx := r.Context()
|
|
ctx = context.WithValue(ctx, "runner_id", runnerID)
|
|
next(w, r.WithContext(ctx))
|
|
}
|
|
}
|
|
|
|
// handleRegisterRunner registers a new runner
|
|
func (s *Server) handleRegisterRunner(w http.ResponseWriter, r *http.Request) {
|
|
var req struct {
|
|
types.RegisterRunnerRequest
|
|
RegistrationToken string `json:"registration_token"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
s.respondError(w, http.StatusBadRequest, "Invalid request body")
|
|
return
|
|
}
|
|
|
|
if req.Name == "" {
|
|
s.respondError(w, http.StatusBadRequest, "Runner name is required")
|
|
return
|
|
}
|
|
|
|
if req.RegistrationToken == "" {
|
|
s.respondError(w, http.StatusBadRequest, "Registration token is required")
|
|
return
|
|
}
|
|
|
|
// Validate registration token
|
|
valid, err := s.secrets.ValidateRegistrationToken(req.RegistrationToken)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to validate token: %v", err))
|
|
return
|
|
}
|
|
if !valid {
|
|
s.respondError(w, http.StatusUnauthorized, "Invalid or expired registration token")
|
|
return
|
|
}
|
|
|
|
// Get manager secret
|
|
managerSecret, err := s.secrets.GetManagerSecret()
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, "Failed to get manager secret")
|
|
return
|
|
}
|
|
|
|
// Generate runner secret
|
|
runnerSecret, err := s.secrets.GenerateRunnerSecret()
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, "Failed to generate runner secret")
|
|
return
|
|
}
|
|
|
|
// Register runner
|
|
result, err := s.db.Exec(
|
|
`INSERT INTO runners (name, hostname, ip_address, status, last_heartbeat, capabilities,
|
|
registration_token, runner_secret, manager_secret, verified)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
req.Name, req.Hostname, req.IPAddress, types.RunnerStatusOnline, time.Now(), req.Capabilities,
|
|
req.RegistrationToken, runnerSecret, managerSecret, true,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to register runner: %v", err))
|
|
return
|
|
}
|
|
|
|
runnerID, _ := result.LastInsertId()
|
|
|
|
// Return runner info with secrets
|
|
s.respondJSON(w, http.StatusCreated, map[string]interface{}{
|
|
"id": runnerID,
|
|
"name": req.Name,
|
|
"hostname": req.Hostname,
|
|
"ip_address": req.IPAddress,
|
|
"status": types.RunnerStatusOnline,
|
|
"runner_secret": runnerSecret,
|
|
"manager_secret": managerSecret,
|
|
"verified": true,
|
|
})
|
|
}
|
|
|
|
// handleRunnerHeartbeat updates runner heartbeat
|
|
func (s *Server) handleRunnerHeartbeat(w http.ResponseWriter, r *http.Request) {
|
|
runnerID, ok := r.Context().Value("runner_id").(int64)
|
|
if !ok {
|
|
s.respondError(w, http.StatusBadRequest, "runner_id not found in context")
|
|
return
|
|
}
|
|
|
|
_, err := s.db.Exec(
|
|
`UPDATE runners SET last_heartbeat = ?, status = ? WHERE id = ?`,
|
|
time.Now(), types.RunnerStatusOnline, runnerID,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to update heartbeat: %v", err))
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusOK, map[string]string{"message": "Heartbeat updated"})
|
|
}
|
|
|
|
// handleGetRunnerTasks gets pending tasks for a runner
|
|
func (s *Server) handleGetRunnerTasks(w http.ResponseWriter, r *http.Request) {
|
|
runnerID, ok := r.Context().Value("runner_id").(int64)
|
|
if !ok {
|
|
s.respondError(w, http.StatusBadRequest, "runner_id not found in context")
|
|
return
|
|
}
|
|
|
|
// Get pending tasks
|
|
rows, err := s.db.Query(
|
|
`SELECT t.id, t.job_id, t.runner_id, t.frame_start, t.frame_end, t.status, t.output_path,
|
|
t.created_at, t.started_at, t.completed_at, t.error_message,
|
|
j.name as job_name, j.output_format
|
|
FROM tasks t
|
|
JOIN jobs j ON t.job_id = j.id
|
|
WHERE t.status = ? AND j.status != ?
|
|
ORDER BY t.created_at ASC
|
|
LIMIT 10`,
|
|
types.TaskStatusPending, types.JobStatusCancelled,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query tasks: %v", err))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
tasks := []map[string]interface{}{}
|
|
for rows.Next() {
|
|
var task types.Task
|
|
var runnerID sql.NullInt64
|
|
var startedAt, completedAt sql.NullTime
|
|
var jobName, outputFormat string
|
|
|
|
err := rows.Scan(
|
|
&task.ID, &task.JobID, &runnerID, &task.FrameStart, &task.FrameEnd,
|
|
&task.Status, &task.OutputPath, &task.CreatedAt,
|
|
&startedAt, &completedAt, &task.ErrorMessage,
|
|
&jobName, &outputFormat,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to scan task: %v", err))
|
|
return
|
|
}
|
|
|
|
if runnerID.Valid {
|
|
task.RunnerID = &runnerID.Int64
|
|
}
|
|
if startedAt.Valid {
|
|
task.StartedAt = &startedAt.Time
|
|
}
|
|
if completedAt.Valid {
|
|
task.CompletedAt = &completedAt.Time
|
|
}
|
|
|
|
// Get input files for the job
|
|
var inputFiles []string
|
|
fileRows, err := s.db.Query(
|
|
`SELECT file_path FROM job_files WHERE job_id = ? AND file_type = ?`,
|
|
task.JobID, types.JobFileTypeInput,
|
|
)
|
|
if err == nil {
|
|
for fileRows.Next() {
|
|
var filePath string
|
|
if err := fileRows.Scan(&filePath); err == nil {
|
|
inputFiles = append(inputFiles, filePath)
|
|
}
|
|
}
|
|
fileRows.Close()
|
|
}
|
|
|
|
tasks = append(tasks, map[string]interface{}{
|
|
"task": task,
|
|
"job_name": jobName,
|
|
"output_format": outputFormat,
|
|
"input_files": inputFiles,
|
|
})
|
|
|
|
// Assign task to runner
|
|
_, err = s.db.Exec(
|
|
`UPDATE tasks SET runner_id = ?, status = ? WHERE id = ?`,
|
|
runnerID, types.TaskStatusRunning, task.ID,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to assign task: %v", err))
|
|
return
|
|
}
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusOK, tasks)
|
|
}
|
|
|
|
// handleCompleteTask marks a task as completed
|
|
func (s *Server) handleCompleteTask(w http.ResponseWriter, r *http.Request) {
|
|
taskID, err := parseID(r, "id")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
var req struct {
|
|
OutputPath string `json:"output_path"`
|
|
Success bool `json:"success"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
s.respondError(w, http.StatusBadRequest, "Invalid request body")
|
|
return
|
|
}
|
|
|
|
status := types.TaskStatusCompleted
|
|
if !req.Success {
|
|
status = types.TaskStatusFailed
|
|
}
|
|
|
|
now := time.Now()
|
|
_, err = s.db.Exec(
|
|
`UPDATE tasks SET status = ?, output_path = ?, completed_at = ?, error_message = ? WHERE id = ?`,
|
|
status, req.OutputPath, now, req.Error, taskID,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to update task: %v", err))
|
|
return
|
|
}
|
|
|
|
// Update job progress
|
|
var jobID int64
|
|
var frameStart, frameEnd int
|
|
err = s.db.QueryRow(
|
|
`SELECT job_id, frame_start, frame_end FROM tasks WHERE id = ?`,
|
|
taskID,
|
|
).Scan(&jobID, &frameStart, &frameEnd)
|
|
if err == nil {
|
|
// Count completed tasks
|
|
var totalTasks, completedTasks int
|
|
s.db.QueryRow(
|
|
`SELECT COUNT(*) FROM tasks WHERE job_id = ?`,
|
|
jobID,
|
|
).Scan(&totalTasks)
|
|
s.db.QueryRow(
|
|
`SELECT COUNT(*) FROM tasks WHERE job_id = ? AND status = ?`,
|
|
jobID, types.TaskStatusCompleted,
|
|
).Scan(&completedTasks)
|
|
|
|
progress := float64(completedTasks) / float64(totalTasks) * 100.0
|
|
|
|
// Update job status
|
|
var jobStatus string
|
|
var outputFormat string
|
|
s.db.QueryRow(`SELECT output_format FROM jobs WHERE id = ?`, jobID).Scan(&outputFormat)
|
|
|
|
if completedTasks == totalTasks {
|
|
jobStatus = string(types.JobStatusCompleted)
|
|
now := time.Now()
|
|
s.db.Exec(
|
|
`UPDATE jobs SET status = ?, progress = ?, completed_at = ? WHERE id = ?`,
|
|
jobStatus, progress, now, jobID,
|
|
)
|
|
|
|
// For MP4 jobs, create a video generation task
|
|
if outputFormat == "MP4" {
|
|
go s.generateMP4Video(jobID)
|
|
}
|
|
} else {
|
|
jobStatus = string(types.JobStatusRunning)
|
|
var startedAt sql.NullTime
|
|
s.db.QueryRow(`SELECT started_at FROM jobs WHERE id = ?`, jobID).Scan(&startedAt)
|
|
if !startedAt.Valid {
|
|
now := time.Now()
|
|
s.db.Exec(`UPDATE jobs SET started_at = ? WHERE id = ?`, now, jobID)
|
|
}
|
|
s.db.Exec(
|
|
`UPDATE jobs SET status = ?, progress = ? WHERE id = ?`,
|
|
jobStatus, progress, jobID,
|
|
)
|
|
}
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusOK, map[string]string{"message": "Task completed"})
|
|
}
|
|
|
|
// handleUpdateTaskProgress updates task progress
|
|
func (s *Server) handleUpdateTaskProgress(w http.ResponseWriter, r *http.Request) {
|
|
_, err := parseID(r, "id")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
var req struct {
|
|
Progress float64 `json:"progress"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
s.respondError(w, http.StatusBadRequest, "Invalid request body")
|
|
return
|
|
}
|
|
|
|
// This is mainly for logging/debugging, actual progress is calculated from completed tasks
|
|
s.respondJSON(w, http.StatusOK, map[string]string{"message": "Progress updated"})
|
|
}
|
|
|
|
// handleDownloadFileForRunner allows runners to download job files
|
|
func (s *Server) handleDownloadFileForRunner(w http.ResponseWriter, r *http.Request) {
|
|
jobID, err := parseID(r, "jobId")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
fileName := chi.URLParam(r, "fileName")
|
|
|
|
// Find the file in the database
|
|
var filePath string
|
|
err = s.db.QueryRow(
|
|
`SELECT file_path FROM job_files WHERE job_id = ? AND file_name = ?`,
|
|
jobID, fileName,
|
|
).Scan(&filePath)
|
|
if err == sql.ErrNoRows {
|
|
s.respondError(w, http.StatusNotFound, "File not found")
|
|
return
|
|
}
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query file: %v", err))
|
|
return
|
|
}
|
|
|
|
// Open and serve file
|
|
file, err := s.storage.GetFile(filePath)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusNotFound, "File not found on disk")
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
w.Header().Set("Content-Type", "application/octet-stream")
|
|
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fileName))
|
|
io.Copy(w, file)
|
|
}
|
|
|
|
// handleUploadFileFromRunner allows runners to upload output files
|
|
func (s *Server) handleUploadFileFromRunner(w http.ResponseWriter, r *http.Request) {
|
|
jobID, err := parseID(r, "jobId")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
err = r.ParseMultipartForm(100 << 20) // 100 MB
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, "Failed to parse form")
|
|
return
|
|
}
|
|
|
|
file, header, err := r.FormFile("file")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, "No file provided")
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
// Save file
|
|
filePath, err := s.storage.SaveOutput(jobID, header.Filename, file)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to save file: %v", err))
|
|
return
|
|
}
|
|
|
|
// Record in database
|
|
_, err = s.db.Exec(
|
|
`INSERT INTO job_files (job_id, file_type, file_path, file_name, file_size)
|
|
VALUES (?, ?, ?, ?, ?)`,
|
|
jobID, types.JobFileTypeOutput, filePath, header.Filename, header.Size,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to record file: %v", err))
|
|
return
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusCreated, map[string]interface{}{
|
|
"file_path": filePath,
|
|
"file_name": header.Filename,
|
|
})
|
|
}
|
|
|
|
// generateMP4Video generates MP4 video from PNG frames for a completed job
|
|
func (s *Server) generateMP4Video(jobID int64) {
|
|
// This would be called by a runner or external process
|
|
// For now, we'll create a special task that runners can pick up
|
|
// In a production system, you might want to use a job queue or have a dedicated video processor
|
|
|
|
// Get all PNG output files for this job
|
|
rows, err := s.db.Query(
|
|
`SELECT file_path, file_name FROM job_files
|
|
WHERE job_id = ? AND file_type = ? AND file_name LIKE '%.png'
|
|
ORDER BY file_name`,
|
|
jobID, types.JobFileTypeOutput,
|
|
)
|
|
if err != nil {
|
|
log.Printf("Failed to query PNG files for job %d: %v", jobID, err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
var pngFiles []string
|
|
for rows.Next() {
|
|
var filePath, fileName string
|
|
if err := rows.Scan(&filePath, &fileName); err == nil {
|
|
pngFiles = append(pngFiles, filePath)
|
|
}
|
|
}
|
|
|
|
if len(pngFiles) == 0 {
|
|
log.Printf("No PNG files found for job %d", jobID)
|
|
return
|
|
}
|
|
|
|
// Note: Video generation will be handled by runners when they complete tasks
|
|
// Runners can check job status and generate MP4 when all frames are complete
|
|
log.Printf("Job %d completed with %d PNG frames - ready for MP4 generation", jobID, len(pngFiles))
|
|
}
|
|
|
|
// handleGetJobStatusForRunner allows runners to check job status
|
|
func (s *Server) handleGetJobStatusForRunner(w http.ResponseWriter, r *http.Request) {
|
|
jobID, err := parseID(r, "jobId")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
var job types.Job
|
|
var startedAt, completedAt sql.NullTime
|
|
|
|
err = s.db.QueryRow(
|
|
`SELECT id, user_id, name, status, progress, frame_start, frame_end, output_format,
|
|
created_at, started_at, completed_at, error_message
|
|
FROM jobs WHERE id = ?`,
|
|
jobID,
|
|
).Scan(
|
|
&job.ID, &job.UserID, &job.Name, &job.Status, &job.Progress,
|
|
&job.FrameStart, &job.FrameEnd, &job.OutputFormat,
|
|
&job.CreatedAt, &startedAt, &completedAt, &job.ErrorMessage,
|
|
)
|
|
|
|
if err == sql.ErrNoRows {
|
|
s.respondError(w, http.StatusNotFound, "Job not found")
|
|
return
|
|
}
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query job: %v", err))
|
|
return
|
|
}
|
|
|
|
if startedAt.Valid {
|
|
job.StartedAt = &startedAt.Time
|
|
}
|
|
if completedAt.Valid {
|
|
job.CompletedAt = &completedAt.Time
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusOK, job)
|
|
}
|
|
|
|
// handleGetJobFilesForRunner allows runners to get job files
|
|
func (s *Server) handleGetJobFilesForRunner(w http.ResponseWriter, r *http.Request) {
|
|
jobID, err := parseID(r, "jobId")
|
|
if err != nil {
|
|
s.respondError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
rows, err := s.db.Query(
|
|
`SELECT id, job_id, file_type, file_path, file_name, file_size, created_at
|
|
FROM job_files WHERE job_id = ? ORDER BY file_name`,
|
|
jobID,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query files: %v", err))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
files := []types.JobFile{}
|
|
for rows.Next() {
|
|
var file types.JobFile
|
|
err := rows.Scan(
|
|
&file.ID, &file.JobID, &file.FileType, &file.FilePath,
|
|
&file.FileName, &file.FileSize, &file.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to scan file: %v", err))
|
|
return
|
|
}
|
|
files = append(files, file)
|
|
}
|
|
|
|
s.respondJSON(w, http.StatusOK, files)
|
|
}
|
|
|