tiny-forge/internal/api/backups.go

package api

import (
	"net/http"
	"os"
	"path/filepath"

	"github.com/alexei/docker-watcher/internal/store"
	"github.com/go-chi/chi/v5"
)

// listBackups handles GET /api/backups.
func (s *Server) listBackups(w http.ResponseWriter, r *http.Request) {
	if s.backupEngine == nil {
		respondError(w, http.StatusServiceUnavailable, "backup engine not initialized")
		return
	}

	backups, err := s.backupEngine.ListBackups()
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to list backups: "+err.Error())
		return
	}

	if backups == nil {
		backups = []store.Backup{}
	}

	respondJSON(w, http.StatusOK, backups)
}

// triggerBackup handles POST /api/backups.
func (s *Server) triggerBackup(w http.ResponseWriter, r *http.Request) {
	if s.backupEngine == nil {
		respondError(w, http.StatusServiceUnavailable, "backup engine not initialized")
		return
	}

	backup, err := s.backupEngine.CreateBackup("manual")
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to create backup: "+err.Error())
		return
	}

	// Prune after manual backup too.
	settings, err := s.store.GetSettings()
	if err == nil && settings.BackupRetentionCount > 0 {
		s.backupEngine.Prune(settings.BackupRetentionCount)
	}

	respondJSON(w, http.StatusCreated, backup)
}

// downloadBackup handles GET /api/backups/{id}/download.
func (s *Server) downloadBackup(w http.ResponseWriter, r *http.Request) {
	if s.backupEngine == nil {
		respondError(w, http.StatusServiceUnavailable, "backup engine not initialized")
		return
	}

	id := chi.URLParam(r, "id")
	backup, err := s.backupEngine.GetBackup(id)
	if err != nil {
		respondError(w, http.StatusNotFound, "backup not found")
		return
	}

	filePath := s.backupEngine.FilePath(backup)
	if _, err := os.Stat(filePath); err != nil {
		respondError(w, http.StatusNotFound, "backup file not found on disk")
		return
	}

	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Disposition", "attachment; filename=\""+filepath.Base(backup.Filename)+"\"")
	http.ServeFile(w, r, filePath)
}

// deleteBackup handles DELETE /api/backups/{id}.
func (s *Server) deleteBackup(w http.ResponseWriter, r *http.Request) {
	if s.backupEngine == nil {
		respondError(w, http.StatusServiceUnavailable, "backup engine not initialized")
		return
	}

	id := chi.URLParam(r, "id")
	if err := s.backupEngine.DeleteBackup(id); err != nil {
		respondError(w, http.StatusInternalServerError, "failed to delete backup: "+err.Error())
		return
	}

	respondJSON(w, http.StatusOK, map[string]string{"status": "deleted"})
}

// restoreBackup handles POST /api/backups/{id}/restore.
// This replaces the current database with the backup. The server should be restarted after.
func (s *Server) restoreBackup(w http.ResponseWriter, r *http.Request) {
	if s.backupEngine == nil {
		respondError(w, http.StatusServiceUnavailable, "backup engine not initialized")
		return
	}

	id := chi.URLParam(r, "id")
	restorePath, err := s.backupEngine.RestorePath(id)
	if err != nil {
		respondError(w, http.StatusNotFound, "backup not found: "+err.Error())
		return
	}

	// Read the backup file.
	backupData, err := os.ReadFile(restorePath)
	if err != nil {
		respondError(w, http.StatusInternalServerError, "failed to read backup file: "+err.Error())
		return
	}

	// Close the current database to release locks.
	if err := s.store.Close(); err != nil {
		respondError(w, http.StatusInternalServerError, "failed to close database: "+err.Error())
		return
	}

	// Write backup over the main database file.
	if err := os.WriteFile(s.dbPath, backupData, 0o644); err != nil {
		respondError(w, http.StatusInternalServerError, "failed to write database: "+err.Error())
		return
	}

	// Remove WAL and SHM files to ensure clean state.
	os.Remove(s.dbPath + "-wal")
	os.Remove(s.dbPath + "-shm")

	respondJSON(w, http.StatusOK, map[string]any{
		"status":  "restored",
		"message": "Database restored. The server needs to be restarted to apply changes.",
	})

	// Signal the server to shut down gracefully so it can be restarted.
	if s.shutdownFunc != nil {
		go s.shutdownFunc()
	}
}