Transcode File Uploading

server/server.go

@@ -95,6 +95,7 @@ func Start(_conf config.Config, tmplFS embed.FS, staticFS embed.FS, migrationsFS
 	mux.Handle("/static/", fs)
 	mux.HandleFunc("/tasks", handleTasks)
 	mux.HandleFunc("/files/{id}", handleFile)
+	mux.HandleFunc("/upload/{id}", handleUpload)
 	mux.HandleFunc("/tasks/{id}", handleTask)
 	mux.HandleFunc("/scan/{id}", handleScan)
 	mux.HandleFunc("/libraries/{id}", handleLibrary)

server/task.go

@@ -210,7 +210,7 @@ func createTask(ctx context.Context, r *http.Request) error {
 		data = types.TranscodeData{Command: types.FFmpegCommand{
 			Args:        []types.Arg{{Flag: "-stats"}, {Flag: "-v", Value: "error"}, {Flag: "-xerror"}},
 			InputFiles:  []types.File{{Path: "input.mkv"}},
-			OutputFiles: []types.File{{Path: "output.mkv", Arguments: []types.Arg{{Flag: "-f", Value: "null"}, {Flag: "-max_muxing_queue_size", Value: "9999"}}}},
+			OutputFiles: []types.File{{Path: "output.mkv", Arguments: []types.Arg{{Flag: "-c:s", Value: "copy"}, {Flag: "-c:a", Value: "aac"}, {Flag: "-c:v", Value: "libsvtav1"}, {Flag: "-crf", Value: "35"}, {Flag: "-preset", Value: "8"}, {Flag: "-max_muxing_queue_size", Value: "9999"}}}},
 		}}
 	} else {
 		return fmt.Errorf("Unkown Task Type: %v", typ)

server/upload.go

@@ -0,0 +1,122 @@
+package server
+
+import (
+	"encoding/base64"
+	"errors"
+	"io"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+
+	"git.lastassault.de/speatzle/morffix/constants"
+)
+
+func handleUpload(w http.ResponseWriter, r *http.Request) {
+	if r.Header.Get(constants.SHARED_SECRET_HEADER) != conf.SharedSecret {
+		w.WriteHeader(http.StatusUnauthorized)
+		return
+	}
+
+	id := r.PathValue("id")
+	if id == "" {
+		http.Error(w, "No id", http.StatusBadRequest)
+		return
+	}
+
+	var count int
+	err := db.QueryRow(r.Context(), "SELECT COUNT(*) FROM tasks WHERE file_id = $1 AND worker_id = $2", id, r.Header.Get(constants.UUID_HEADER)).Scan(&count)
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Query Task Count", "err", err)
+		http.Error(w, "Error Query Task Count: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if count < 1 {
+		slog.ErrorContext(r.Context(), "No Running Task for file", "id", id)
+		http.Error(w, "No Running Task for file: "+id, http.StatusBadRequest)
+		return
+	}
+
+	hash, err := base64.StdEncoding.DecodeString(r.Header.Get(constants.HASH_HEADER))
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Decode Hash", "err", err)
+		http.Error(w, "Decode Hash: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	var fPath string
+	var libraryID int
+	err = db.QueryRow(r.Context(), "SELECT path, library_id FROM files WHERE id = $1", id).Scan(&fPath, &libraryID)
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Query File Path", "err", err)
+		http.Error(w, "Error Query File Path: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var lPath string
+	var tPath string
+	var tReplace bool
+	err = db.QueryRow(r.Context(), "SELECT path, transcode_path, transcode_replace FROM libraries WHERE id = $1", libraryID).Scan(&lPath, &tPath, &tReplace)
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Query Library Path", "err", err)
+		http.Error(w, "Error Query Library Path: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var path string
+	if tReplace {
+		//path = filepath.Join(lPath, fPath)
+		slog.ErrorContext(r.Context(), "Replace mode is not implemented")
+		http.Error(w, "Replace mode is not implemented", http.StatusNotImplemented)
+		return
+	} else {
+		path = filepath.Join(tPath, fPath)
+	}
+
+	slog.InfoContext(r.Context(), "Starting multipart Parsing for file", "id", id, "path", path)
+
+	err = r.ParseMultipartForm(100 << 20)
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Parse Multipart Form", "err", err)
+		http.Error(w, "Parse Multipart Form: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	srcFile, _, err := r.FormFile(constants.FORM_FILE_KEY)
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Parse Multipart Form", "err", err)
+		http.Error(w, "Parse Multipart Form: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	src := http.MaxBytesReader(w, srcFile, 1000000<<20)
+	// MaxBytesReader closes the underlying io.Reader on its Close() is called
+	defer src.Close()
+
+	out, err := os.Create(path)
+	if err != nil {
+		slog.ErrorContext(r.Context(), "Creating File", "err", err)
+		http.Error(w, "Creating File: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer out.Close()
+
+	written, err := io.Copy(out, src)
+	if err != nil {
+		var maxBytesError *http.MaxBytesError
+		if errors.As(err, &maxBytesError) {
+			slog.ErrorContext(r.Context(), "Parse Multipart Form", "err", err)
+			http.Error(w, "Parse Multipart Form: "+err.Error(), http.StatusRequestEntityTooLarge)
+			return
+		}
+		slog.ErrorContext(r.Context(), "Failed to write the uploaded content", "err", err)
+		http.Error(w, "Failed to write the uploaded content: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// TODO check file integrity
+	_ = hash
+
+	slog.InfoContext(r.Context(), "upload done", "written", written)
+}