fixes

pkg/scanner/rescanner.go

@@ -0,0 +1,139 @@
+package scanner
+
+import (
+	"context"
+	"time"
+
+	"github.com/lukaszraczylo/gohoarder/pkg/metadata"
+	"github.com/rs/zerolog/log"
+)
+
+// RescanWorker handles periodic re-scanning of cached packages
+type RescanWorker struct {
+	manager       *Manager
+	metadataStore metadata.MetadataStore
+	interval      time.Duration
+	stopCh        chan struct{}
+}
+
+// NewRescanWorker creates a new rescan worker
+func NewRescanWorker(manager *Manager, metadataStore metadata.MetadataStore, interval time.Duration) *RescanWorker {
+	return &RescanWorker{
+		manager:       manager,
+		metadataStore: metadataStore,
+		interval:      interval,
+		stopCh:        make(chan struct{}),
+	}
+}
+
+// Start begins the periodic re-scanning process
+func (w *RescanWorker) Start(ctx context.Context) {
+	if !w.manager.enabled || w.interval == 0 {
+		log.Info().Msg("Rescan worker disabled")
+		return
+	}
+
+	log.Info().
+		Dur("interval", w.interval).
+		Msg("Starting package rescan worker")
+
+	ticker := time.NewTicker(w.interval)
+	defer ticker.Stop()
+
+	// Run initial scan immediately
+	w.rescanPackages(ctx)
+
+	for {
+		select {
+		case <-ticker.C:
+			w.rescanPackages(ctx)
+		case <-w.stopCh:
+			log.Info().Msg("Rescan worker stopped")
+			return
+		case <-ctx.Done():
+			log.Info().Msg("Rescan worker stopped (context cancelled)")
+			return
+		}
+	}
+}
+
+// Stop stops the rescan worker
+func (w *RescanWorker) Stop() {
+	close(w.stopCh)
+}
+
+// rescanPackages re-scans packages that need updating
+func (w *RescanWorker) rescanPackages(ctx context.Context) {
+	log.Info().Msg("Starting package rescan cycle")
+
+	// Get all packages
+	packages, err := w.metadataStore.ListPackages(ctx, &metadata.ListOptions{})
+	if err != nil {
+		log.Error().Err(err).Msg("Failed to list packages for rescan")
+		return
+	}
+
+	scanned := 0
+	skipped := 0
+	failed := 0
+
+	for _, pkg := range packages {
+		// Check if package needs rescanning
+		needsRescan, err := w.needsRescan(ctx, pkg)
+		if err != nil {
+			log.Error().
+				Err(err).
+				Str("package", pkg.Name).
+				Str("version", pkg.Version).
+				Msg("Failed to check rescan status")
+			failed++
+			continue
+		}
+
+		if !needsRescan {
+			skipped++
+			continue
+		}
+
+		// Rescan the package
+		// Note: We need the file path - we'll need to reconstruct it or get it from storage
+		// For now, we'll just log and skip actual rescanning
+		log.Info().
+			Str("registry", pkg.Registry).
+			Str("package", pkg.Name).
+			Str("version", pkg.Version).
+			Msg("Package needs rescanning")
+
+		// TODO: Implement actual rescanning by:
+		// 1. Retrieving package file from storage
+		// 2. Scanning it
+		// This would require access to storage backend
+
+		scanned++
+	}
+
+	log.Info().
+		Int("total", len(packages)).
+		Int("scanned", scanned).
+		Int("skipped", skipped).
+		Int("failed", failed).
+		Msg("Rescan cycle completed")
+}
+
+// needsRescan checks if a package needs to be rescanned
+func (w *RescanWorker) needsRescan(ctx context.Context, pkg *metadata.Package) (bool, error) {
+	// Get latest scan result
+	scanResult, err := w.metadataStore.GetScanResult(ctx, pkg.Registry, pkg.Name, pkg.Version)
+	if err != nil {
+		// No scan result - needs scanning
+		return true, nil
+	}
+
+	// Check if scan is older than rescan interval
+	timeSinceLastScan := time.Since(scanResult.ScannedAt)
+	if timeSinceLastScan >= w.interval {
+		return true, nil
+	}
+
+	return false, nil
+}