chore: reorder part two

internal/server/database/watchdog.go

@@ -0,0 +1,130 @@
+package database
+
+import (
+	"errors"
+	"log/slog"
+	"orbits-server/internal/server/bootstrap"
+	"orbits-server/internal/shared/utility"
+	"os"
+	"path/filepath"
+
+	"gorm.io/gorm"
+)
+
+func filesystemGather(env bootstrap.Environment) (map[string]struct{}, error) {
+	fsFiles, err := os.ReadDir(env.ContentDirectory)
+	if err != nil {
+		slog.Error("failed to read the content directory on the filesystem", "error", err)
+		return nil, err
+	}
+
+	// generate a set of filesystem contents
+	fsSet := make(map[string]struct{}) // cool name for the files that are (now) marked for annihilation
+	for _, f := range fsFiles {
+		// absolute path creation
+		fullPath := filepath.Join(env.ContentDirectory, f.Name())
+		fsSet[fullPath] = struct{}{}
+	}
+
+	return fsSet, nil
+}
+
+func databaseGather(db *gorm.DB) (map[string]File, error) {
+	dbFiles, err := GetFiles(db)
+	if err != nil {
+		slog.Error("failed to retrieve the files indexed from the database", "error", err)
+		return nil, err
+	}
+
+	// generate a set of Database contents
+	dbSet := make(map[string]File) // cool name for the files that are going to be deregistered from the database
+	for _, f := range dbFiles {
+		dbSet[f.FilePath] = f
+	}
+
+	return dbSet, nil
+}
+
+func watchdog(env bootstrap.Environment, db *gorm.DB) {
+	slog.Debug("performing the watchdog cycle")
+
+	fsSet, err := filesystemGather(env)
+	if err != nil {
+		return
+	}
+	dbSet, err := databaseGather(db)
+	if err != nil {
+		return
+	}
+
+	// FS -> DB
+	// check for orphaned filesystem files
+	var fsOrphans []string
+	for path := range fsSet {
+		if _, exists := dbSet[path]; !exists {
+			fsOrphans = append(fsOrphans, path)
+		}
+	}
+
+	if len(fsOrphans) > 0 {
+		slog.Info("filesystem orphans detected, engaging flow")
+		//filepath is stored in the slice, the filename or file object, see above
+
+		for _, fp := range fsOrphans {
+			// this switch is guarded by the environment.go its check making sure its one of the three
+			// the following logic is used to actually perform the sync modes, removal, enrollment or ignore
+			switch env.WatchdogSyncMode {
+			case "sync":
+				readerStream, err := os.Open(fp)
+				if err != nil {
+					slog.Error("failed to a reader stream")
+				}
+				defer readerStream.Close()
+
+				fileData, err := BuildFileRecord(readerStream, filepath.Base(fp), env.ContentDirectory)
+				if err != nil {
+					slog.Error("failed to enroll local file into the database", "error", err)
+				}
+
+				if err := RegisterFile(db, fileData); err != nil {
+					if errors.Is(err, gorm.ErrDuplicatedKey) {
+						slog.Debug("discarding file since its a duplicate", "error", err)
+					} else {
+						slog.Error("failed to insert filedata to the database", "error", err)
+					}
+				}
+
+				// to fully finalize the enrollment process, we rename the locally inserted file to a unique filename
+				// this is to make all files comply, wether uploaded via the api or locally inserted with the filesystem
+				if err := os.Rename(fp, fileData.FilePath); err != nil {
+					slog.Error("failed to move the locally inserted file", "error", err)
+				}
+
+			case "strict":
+				err := utility.RemoveFile(fp)
+				if err != nil {
+					slog.Error("failed to remove local file from the filesystem", "error", err)
+				}
+			case "dry":
+				slog.Debug("dry mode enabled, not purging", "filepath", fp)
+			}
+		}
+
+	}
+
+	// DB -> FS
+	// check stale database records
+	var dbdbOrphans []File
+	for path, f := range dbSet {
+		if _, exists := fsSet[path]; !exists {
+			dbdbOrphans = append(dbdbOrphans, f)
+		}
+	}
+
+	if len(dbdbOrphans) > 0 {
+		slog.Info("database orphans detected, engaging flow")
+		for _, f := range dbdbOrphans {
+			DeregisterFile(db, f)
+		}
+	}
+}