Files
mtusi2026lab4/cmd/server/main.go
T
Mlvn 7cbb75c897 Реализовать lab4: вложения S3/MinIO, уровень 4 и трек 2 reconciler.
Метаданные в PostgreSQL, байты в приватном bucket; sync upload 201 ready;
компенсация orphan и cmd/reconcile с dry-run/apply и grace period.
2026-11-12 18:08:47 +03:00

215 lines
5.1 KiB
Go

// Точка входа HTTP API и одноразового мигратора lab4.
//
// Режимы:
//
// (по умолчанию) — API-реплика: Postgres + Redis + S3, миграции НЕ применяет;
// -migrate — применить SQL и выйти (S3 не нужен);
// -healthcheck — локальный probe /health/ready.
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"mtusi2026lab4/internal/api"
"mtusi2026lab4/internal/auth"
"mtusi2026lab4/internal/blob"
"mtusi2026lab4/internal/config"
"mtusi2026lab4/internal/session"
"mtusi2026lab4/internal/store"
)
func main() {
healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit")
migrateOnly := flag.Bool("migrate", false, "apply SQL migrations and exit")
flag.Parse()
if *healthcheck {
os.Exit(runHealthcheck())
}
cfg, err := config.Load()
if err != nil {
log.Fatalf("config: %v", err)
}
hasher, err := auth.NewHasher()
if err != nil {
log.Fatalf("password hasher: %v", err)
}
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher, cfg.MaxConns)
if err != nil {
log.Fatalf("postgres: %v", err)
}
defer st.Close()
if *migrateOnly || cfg.RunMigrations {
if err := st.Migrate(rootCtx); err != nil {
log.Fatalf("migrate: %v", err)
}
log.Printf("migrations applied")
if *migrateOnly {
return
}
}
sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL)
if err != nil {
log.Fatalf("redis: %v", err)
}
defer sessions.Close()
s3cfg, err := config.LoadS3()
if err != nil {
log.Fatalf("s3 config: %v", err)
}
blobs, err := waitS3(rootCtx, s3cfg)
if err != nil {
log.Fatalf("s3: %v", err)
}
srvAPI := api.New(st, sessions, blobs, cfg.InstanceID)
srvAPI.MaxUploadBytes = cfg.MaxUploadBytes
srvAPI.MaxImagePixels = cfg.MaxImagePixels
httpServer := &http.Server{
Addr: cfg.Addr(),
Handler: srvAPI.Handler(),
ReadHeaderTimeout: 5 * time.Second,
// Upload до 10 MiB: даём запас на медленный клиент.
ReadTimeout: 60 * time.Second,
WriteTimeout: 60 * time.Second,
IdleTimeout: 60 * time.Second,
}
errCh := make(chan error, 1)
go func() {
log.Printf("listening on %s env=%s instance=%s session_ttl=%s db_max_conns=%d bucket=%s",
cfg.Addr(), cfg.Env, cfg.InstanceID, cfg.SessionTTL, cfg.MaxConns, s3cfg.Bucket)
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
errCh <- err
}
}()
select {
case err := <-errCh:
log.Fatalf("listen: %v", err)
case <-rootCtx.Done():
}
log.Printf("shutting down instance=%s", cfg.InstanceID)
srvAPI.BeginDrain()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := httpServer.Shutdown(ctx); err != nil {
log.Printf("shutdown error: %v", err)
os.Exit(1)
}
log.Printf("shutdown complete")
}
func waitPostgres(ctx context.Context, dsn string, hasher *auth.Hasher, maxConns int32) (*store.Store, error) {
deadline := time.Now().Add(45 * time.Second)
var last error
for {
st, err := store.Open(ctx, dsn, hasher, maxConns)
if err == nil {
return st, nil
}
last = err
if ctx.Err() != nil || time.Now().After(deadline) {
return nil, last
}
log.Printf("postgres not ready, retrying")
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-time.After(time.Second):
}
}
}
func waitRedis(ctx context.Context, redisURL string, ttl time.Duration) (*session.Store, error) {
deadline := time.Now().Add(45 * time.Second)
var last error
for {
st, err := session.Open(redisURL, ttl)
if err == nil {
return st, nil
}
last = err
if ctx.Err() != nil || time.Now().After(deadline) {
return nil, last
}
log.Printf("redis not ready, retrying")
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-time.After(time.Second):
}
}
}
func waitS3(ctx context.Context, cfg config.S3) (*blob.Client, error) {
deadline := time.Now().Add(45 * time.Second)
var last error
for {
c, err := blob.New(blob.Config{
Endpoint: cfg.Endpoint,
UseSSL: cfg.UseSSL,
Region: cfg.Region,
Bucket: cfg.Bucket,
AccessKey: cfg.AccessKey,
SecretKey: cfg.SecretKey,
})
if err == nil {
if err = c.Ping(ctx); err == nil {
return c, nil
}
last = err
} else {
last = err
}
if ctx.Err() != nil || time.Now().After(deadline) {
return nil, last
}
log.Printf("s3 not ready, retrying")
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-time.After(time.Second):
}
}
}
func runHealthcheck() int {
cfg, err := config.Load()
if err != nil {
return 1
}
host := cfg.Host
if host == "0.0.0.0" || host == "::" {
host = "127.0.0.1"
}
client := &http.Client{Timeout: 2 * time.Second}
resp, err := client.Get(fmt.Sprintf("http://%s:%d/health/ready", host, cfg.Port))
if err != nil {
return 1
}
defer resp.Body.Close()
_, _ = io.Copy(io.Discard, resp.Body)
if resp.StatusCode != http.StatusOK {
return 1
}
return 0
}