DaanSelen
131 lines
3.5 KiB
Go
131 lines
3.5 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|