deploy-felhom-compose/controller/internal/web/handler_restore.go

package web

import (
	"context"
	"encoding/json"
	"net/http"
	"time"

	"gitea.dooplex.hu/admin/felhom-controller/internal/backup"
)

// restorePageHandler renders the full-page DR restore UI.
func (s *Server) restorePageHandler(w http.ResponseWriter, r *http.Request) {
	s.restoreMu.RLock()
	plan := s.restorePlan
	if plan == nil {
		s.restoreMu.RUnlock()
		http.Redirect(w, r, "/", http.StatusFound)
		return
	}
	// Snapshot all needed fields under lock before rendering
	customerID := plan.CustomerID
	timestamp := plan.Timestamp
	apps := plan.GetApps()
	drives := make([]backup.DriveInfo, len(plan.Drives))
	copy(drives, plan.Drives)
	status := plan.GetStatus()
	s.restoreMu.RUnlock()

	data := map[string]interface{}{
		"Title":        "Katasztrófa utáni visszaállítás",
		"CustomerName": s.cfg.Customer.Name,
		"Domain":       s.cfg.Customer.Domain,
		"Version":      s.version,
		"CustomerID":   customerID,
		"Timestamp":    timestamp,
		"Apps":         apps,
		"Drives":       drives,
		"PlanStatus":   status,
	}

	s.render(w, "restore", data)
}

// apiRestoreStatus returns the current restore plan status as JSON.
func (s *Server) apiRestoreStatus(w http.ResponseWriter, r *http.Request) {
	s.restoreMu.RLock()
	plan := s.restorePlan
	if plan == nil {
		s.restoreMu.RUnlock()
		jsonError(w, "not in restore mode", http.StatusBadRequest)
		return
	}
	snapshot := plan.Snapshot()
	s.restoreMu.RUnlock()

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	json.NewEncoder(w).Encode(snapshot)
}

// apiRestoreAll starts restoring all pending apps sequentially.
func (s *Server) apiRestoreAll(w http.ResponseWriter, r *http.Request) {
	s.restoreMu.RLock()
	plan := s.restorePlan
	s.restoreMu.RUnlock()
	if plan == nil {
		jsonError(w, "not in restore mode", http.StatusBadRequest)
		return
	}
	if !plan.TryStartRestore() {
		jsonError(w, "restore already in progress", http.StatusConflict)
		return
	}
	go s.executeAllRestores()

	jsonResponse(w, map[string]interface{}{
		"ok":      true,
		"message": "Visszaállítás elindítva",
	})
}

// apiRestoreSkip exits restore mode without restoring.
func (s *Server) apiRestoreSkip(w http.ResponseWriter, r *http.Request) {
	s.restoreMu.RLock()
	plan := s.restorePlan
	s.restoreMu.RUnlock()
	if plan == nil {
		jsonError(w, "not in restore mode", http.StatusBadRequest)
		return
	}

	s.logger.Println("[INFO] User skipped DR restore — entering normal mode")
	s.clearRestoreMode()

	jsonResponse(w, map[string]interface{}{
		"ok":      true,
		"message": "Visszaállítás kihagyva",
	})
}

// executeAllRestores runs the restore for each pending app sequentially.
func (s *Server) executeAllRestores() {
	s.logger.Println("[INFO] Starting DR restore for all apps")

	s.restoreMu.RLock()
	plan := s.restorePlan
	s.restoreMu.RUnlock()
	if plan == nil {
		s.logger.Println("[WARN] Restore plan cleared before execution could start")
		return
	}

	for i := range plan.Apps {
		app := &plan.Apps[i]
		if app.Status != "pending" {
			continue
		}

		plan.UpdateApp(app.Name, "restoring", "")
		s.logger.Printf("[INFO] Restoring app %s (%s)", app.Name, app.DisplayName)

		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
		err := backup.RestoreAppFromBackup(ctx, app, s.cfg.Paths.StacksDir, s.logger)
		cancel()

		if err != nil {
			plan.UpdateApp(app.Name, "failed", err.Error())
			s.logger.Printf("[ERROR] Restore failed for %s: %v", app.Name, err)
		} else {
			plan.UpdateApp(app.Name, "done", "")
			s.logger.Printf("[INFO] Restore completed for %s", app.Name)
		}
	}

	plan.SetStatus("done")
	s.logger.Println("[INFO] All app restores completed")

	// Re-scan stacks so dashboard picks up restored apps
	if s.stackMgr != nil {
		if err := s.stackMgr.ScanStacks(); err != nil {
			s.logger.Printf("[WARN] Post-restore stack scan failed: %v", err)
		}
	}
}

// clearRestoreMode exits restore mode and returns to normal operation.
func (s *Server) clearRestoreMode() {
	s.restoreMu.Lock()
	defer s.restoreMu.Unlock()
	s.restorePlan = nil
}