package main import ( "context" "errors" "fmt" "log" "net/http" "os" "os/signal" "sync" "syscall" "time" "github.com/gin-gonic/gin" "github.com/kazier/backend/config" "github.com/kazier/backend/db" "github.com/kazier/backend/handlers" "github.com/kazier/backend/ocr" "github.com/kazier/backend/pkg/auth" "github.com/kazier/backend/repository" "github.com/kazier/backend/service" ) var version = "dev" func newRouter() *gin.Engine { r := gin.Default() handlers.RegisterRoutes(r) return r } func main() { if len(os.Args) > 1 && os.Args[1] == "--version" { fmt.Printf("kazier-server %s\n", version) os.Exit(0) } cfg, err := config.LoadApplicationConfig() if err != nil { log.Fatalln(err) } // Migrations AVANT l'ouverture du pool applicatif : un seul *sql.DB vit à // la fois (MigrateDatabase ouvre/ferme sa propre connexion éphémère). // Inter-lots : pour partager strictement le même pool, db doit exposer // Migrate(conn *sql.DB) — fichier LOT 4 (db/db.go), non édité ici. if err := db.MigrateDatabase(cfg.DatabaseURL); err != nil { log.Fatalf("migrations postgres: %v", err) } conn, err := db.Open(cfg.DatabaseURL) if err != nil { log.Fatalf("connexion postgres: %v", err) } defer conn.Close() authManager, err := auth.NewManager(cfg.AuthSecret) if err != nil { log.Fatalln(err) } handlers.Auth = authManager repo := repository.NewRepository(conn) // Premier admin (users vide) — refus de démarrer si identifiants absents. // Concurrence au boot (2 instances, users vide) : le perdant de l'INSERT // reçoit ErrNameConflict (UNIQUE username_normalized) → recompte avant de // refuser de démarrer (retry logique, sans toucher bootstrap.go — LOT 4). if err := service.EnsureAdmin(repo, cfg.AdminUsername, cfg.AdminPassword); err != nil { if errors.Is(err, repository.ErrNameConflict) { if n, cerr := repo.Users.Count(); cerr == nil && n > 0 { log.Println("bootstrap admin: compte créé par une instance concurrente, démarrage poursuivi") } else { log.Fatalln(err) } } else { log.Fatalln(err) } } handlers.Store = service.NewResources( repo, cfg.UploadDir, cfg.MaxFileSizeMB*1024*1024, ) handlers.Ocr = service.NewOcr(repo, cfg.UploadDir, cfg.OcrLang, ocr.NewTesseract()) // V3 S2 : faits génériques — chaque texte OCR extrait alimente // `resource_facts` (origin='auto'). Enrichissement best-effort : un // échec d'extract ne fait jamais échouer le job OCR. extractSvc := service.NewExtract(repo) handlers.Ocr.OnText = func(userID, resourceID, text string) { if err := extractSvc.ProcessText(userID, resourceID, text); err != nil { log.Printf("extract: %s: %v", resourceID, err) } } // V3 S5 : backfill des hashes (uploads d'avant la V3) — doublons. go func() { n, err := handlers.Store.BackfillHashes(200) if err != nil { log.Printf("content backfill hashes: %v", err) return } if n > 0 { log.Printf("content backfill hashes: %d fichiers", n) } }() ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() // Worker OCR borné (OCR_WORKERS) : file `ocr_jobs`, hors request handlers. // WaitGroup + budget d'arrêt partagé (5s, voir shutdown plus bas) : le // worker finit le job en cours ; passé le délai, le process sort et le job // resté `processing` sera requeue au prochain boot (ResetStaleProcessing). var ocrWg sync.WaitGroup ocrWg.Add(1) go func() { defer ocrWg.Done() handlers.Ocr.Run(ctx, cfg.OcrWorkers) }() log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers) // V3 S2 : backfill extract (une passe bornée au boot — les ressources // avec ocr_text mais sans faits auto, ex. OCR d'avant la V3). go func() { n, err := extractSvc.Backfill(200) if err != nil { log.Printf("extract backfill: %v", err) return } if n > 0 { log.Printf("extract backfill: %d ressources enrichies", n) } }() // V3 corbeille : passe de purge (trash > TrashRetention) au boot puis // toutes les heures. Best-effort : une passe ratée sera rejouée à la // suivante, jamais de crash serveur sur une erreur de purge. go func() { purge := func() { n, err := handlers.Store.PurgeExpiredTrash(service.TrashRetention) if err != nil { log.Printf("purge corbeille: %v", err) return } if n > 0 { log.Printf("purge corbeille: %d ressources détruites", n) } } purge() ticker := time.NewTicker(time.Hour) defer ticker.Stop() for { select { case <-ctx.Done(): return case <-ticker.C: purge() } } }() log.Printf("purge corbeille démarrée (rétention %s)", service.TrashRetention) srv := &http.Server{ Addr: fmt.Sprintf(":%d", cfg.Port), Handler: newRouter(), } go func() { if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { log.Fatalf("server: %v", err) } }() <-ctx.Done() stop() shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() if err := srv.Shutdown(shutdownCtx); err != nil { log.Printf("shutdown: %v", err) } // Le worker OCR dispose du même budget de 5s : on attend la fin du job en // cours, passé ce délai le process sort (job resté `processing` → requeue // au prochain boot via ResetStaleProcessing, jamais de job perdu). ocrDone := make(chan struct{}) go func() { ocrWg.Wait() close(ocrDone) }() select { case <-ocrDone: log.Println("worker OCR arrêté") case <-shutdownCtx.Done(): log.Println("worker OCR: budget 5s écoulé, arrêt forcé (jobs `processing` requeues au prochain boot)") } log.Println("arrêt propre") }