Files
mtusi2026lab4/cmd/server/main.go
T

284 lines
8.4 KiB
Go

package main
import (
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"log"
"net/http"
"os"
"os/signal"
"path/filepath"
"sort"
"strconv"
"strings"
"syscall"
"time"
"github.com/google/uuid"
"messenger/internal/handler"
"messenger/internal/s3store"
"messenger/internal/store"
)
func getEnv(key, defaultVal string) string {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
return val
}
return defaultVal
}
func getEnvInt(key string, defaultVal int) int {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
if n, err := strconv.Atoi(val); err == nil {
return n
}
}
return defaultVal
}
func getEnvInt64(key string, defaultVal int64) int64 {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
if n, err := strconv.ParseInt(val, 10, 64); err == nil {
return n
}
}
return defaultVal
}
func getEnvBool(key string, defaultVal bool) bool {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
if b, err := strconv.ParseBool(val); err == nil {
return b
}
}
return defaultVal
}
func resolveSecretOrEnv(fileEnvKey, directEnvKey, defaultVal string) string {
if filePath := strings.TrimSpace(os.Getenv(fileEnvKey)); filePath != "" {
if data, err := os.ReadFile(filePath); err == nil {
if trimmed := strings.TrimSpace(string(data)); trimmed != "" {
return trimmed
}
}
}
if direct := strings.TrimSpace(os.Getenv(directEnvKey)); direct != "" {
return direct
}
return defaultVal
}
func resolveInstanceID() string {
if id := strings.TrimSpace(os.Getenv("INSTANCE_ID")); id != "" {
return id
}
if host, err := os.Hostname(); err == nil && strings.TrimSpace(host) != "" {
return strings.TrimSpace(host)
}
return "api-" + uuid.New().String()[:12]
}
func loadMigrations(dir string) ([]store.MigrationFile, error) {
entries, err := os.ReadDir(dir)
if err != nil {
return nil, fmt.Errorf("read migrations dir %s: %w", dir, err)
}
var names []string
for _, entry := range entries {
if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".sql") {
names = append(names, entry.Name())
}
}
sort.Strings(names)
if len(names) == 0 {
return nil, fmt.Errorf("no .sql migration files found in %s", dir)
}
migrations := make([]store.MigrationFile, 0, len(names))
for _, name := range names {
raw, err := os.ReadFile(filepath.Join(dir, name))
if err != nil {
return nil, fmt.Errorf("read migration %s: %w", name, err)
}
migrations = append(migrations, store.MigrationFile{
Version: name,
SQL: string(raw),
})
}
return migrations, nil
}
func main() {
migrateOnly := flag.Bool("migrate-only", false, "Run database migrations and exit")
reconcileOnce := flag.Bool("reconcile-once", false, "Run two-store (DB <-> S3) reconciliation once and exit")
reconcileDryRun := flag.Bool("dry-run", false, "Dry-run mode for -reconcile-once")
reconcileGraceSec := flag.Int("grace-seconds", -1, "Override grace period in seconds for -reconcile-once")
flag.Parse()
host := getEnv("APP_HOST", "0.0.0.0")
port := getEnv("APP_PORT", "8080")
appEnv := getEnv("APP_ENV", "lab")
sessionTTL := getEnvInt("SESSION_TTL_SECONDS", 3600)
idempotencyTTL := getEnvInt("IDEMPOTENCY_TTL_SECONDS", 86400)
maxConns := int32(getEnvInt("DB_MAX_CONNS", 12))
minConns := int32(getEnvInt("DB_MIN_CONNS", 2))
queryTimeoutMs := getEnvInt("DB_QUERY_TIMEOUT_MS", 5000)
drainDelayMs := getEnvInt("SHUTDOWN_DRAIN_DELAY_MS", 1500)
cacheMode := getEnv("CACHE_MODE", "write_through_versioned")
writeMode := getEnv("WRITE_MODE", "pipeline")
migrationsDir := getEnv("MIGRATIONS_DIR", "migrations")
runMigrations := *migrateOnly || getEnvBool("RUN_MIGRATIONS", true)
maxUploadBytes := getEnvInt64("MAX_UPLOAD_BYTES", 10485760)
maxImagePixels := getEnvInt64("MAX_IMAGE_PIXELS", 40000000)
reconcileIntervalSec := getEnvInt("RECONCILE_INTERVAL_SECONDS", 60)
reconcileGraceEnv := getEnvInt("RECONCILE_GRACE_SECONDS", 300)
if *reconcileGraceSec >= 0 {
reconcileGraceEnv = *reconcileGraceSec
}
instanceID := resolveInstanceID()
dbURL := resolveSecretOrEnv("DATABASE_URL_FILE", "DATABASE_URL", "postgres://messenger:messenger_lab4_pass@localhost:5432/messenger?sslmode=disable")
cacheURL := resolveSecretOrEnv("CACHE_URL_FILE", "CACHE_URL", "redis://localhost:6379/0")
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
st, err := store.NewPostgresStore(ctx, store.Config{
DatabaseURL: dbURL,
CacheURL: cacheURL,
MaxConns: maxConns,
MinConns: minConns,
QueryTimeout: time.Duration(queryTimeoutMs) * time.Millisecond,
CacheMode: cacheMode,
WriteMode: writeMode,
})
if err != nil {
log.Fatalf("Failed to initialize store: %v", err)
}
defer st.Close()
if runMigrations && !*reconcileOnce {
migrations, err := loadMigrations(migrationsDir)
if err != nil {
log.Fatalf("Failed to load migrations: %v", err)
}
var migErr error
for attempt := 1; attempt <= 30; attempt++ {
migErr = st.RunMigrations(ctx, migrations)
if migErr == nil {
break
}
log.Printf("Waiting for PostgreSQL to apply migrations (attempt %d/30): %v", attempt, migErr)
select {
case <-ctx.Done():
log.Fatalf("Interrupted while waiting for database migrations")
case <-time.After(1 * time.Second):
}
}
if migErr != nil {
log.Fatalf("Could not apply database migrations after 30 attempts: %v", migErr)
}
}
if *migrateOnly {
log.Println("Migrate-only flag set; exiting 0.")
return
}
s3Endpoint := getEnv("S3_ENDPOINT", "http://s3:9000")
s3Region := getEnv("S3_REGION", "us-east-1")
s3Bucket := getEnv("S3_BUCKET", "messenger-attachments")
s3AccessKey := resolveSecretOrEnv("S3_ACCESS_KEY_ID_FILE", "S3_ACCESS_KEY_ID", "messenger_api_key")
s3SecretKey := resolveSecretOrEnv("S3_SECRET_ACCESS_KEY_FILE", "S3_SECRET_ACCESS_KEY", "messenger_api_secret_key_lab4")
s3Client, err := s3store.NewClient(s3store.Config{
Endpoint: s3Endpoint,
Region: s3Region,
Bucket: s3Bucket,
AccessKey: s3AccessKey,
SecretKey: s3SecretKey,
})
if err != nil {
log.Fatalf("Failed to initialize S3 client: %v", err)
}
if *reconcileOnce {
grace := time.Duration(reconcileGraceEnv) * time.Second
report, rErr := st.Reconcile(ctx, s3Client, grace, *reconcileDryRun)
if rErr != nil {
log.Fatalf("Reconcile failed: %v", rErr)
}
out, _ := json.MarshalIndent(report, "", " ")
fmt.Println(string(out))
return
}
// Background two-store reconciliation loop (only 1 replica acquires advisory lock per interval).
if reconcileIntervalSec > 0 {
go func() {
ticker := time.NewTicker(time.Duration(reconcileIntervalSec) * time.Second)
defer ticker.Stop()
grace := time.Duration(reconcileGraceEnv) * time.Second
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
rCtx, rCancel := context.WithTimeout(ctx, 25*time.Second)
rep, rErr := st.Reconcile(rCtx, s3Client, grace, false)
rCancel()
if rErr != nil {
log.Printf("WARN: background reconcile error: %v", rErr)
} else if rep.LockAcquired && (len(rep.OrphanS3Deleted) > 0 || len(rep.MissingS3MarkedFailed) > 0 || len(rep.MissingS3Deleted) > 0) {
b, _ := json.Marshal(rep)
log.Printf("Background reconcile summary: %s", string(b))
}
}
}
}()
}
h, apiHandler := handler.RegisterRoutes(st, s3Client, sessionTTL, idempotencyTTL, maxUploadBytes, maxImagePixels, instanceID)
addr := fmt.Sprintf("%s:%s", host, port)
srv := &http.Server{
Addr: addr,
Handler: h,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 35 * time.Second,
WriteTimeout: 35 * time.Second,
IdleTimeout: 60 * time.Second,
}
go func() {
log.Printf("Starting messenger server (Lab 4, instance=%s) on %s (env=%s, s3=%s/%s, maxUpload=%dB, maxPixels=%d)",
instanceID, addr, appEnv, s3Endpoint, s3Bucket, maxUploadBytes, maxImagePixels)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("ListenAndServe error: %v", err)
}
}()
<-ctx.Done()
log.Printf("Instance %s received termination signal: marking /health/ready=503 and draining...", instanceID)
apiHandler.SetDraining(true)
if drainDelayMs > 0 {
time.Sleep(time.Duration(drainDelayMs) * time.Millisecond)
}
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("Server shutdown error: %v", err)
} else {
log.Printf("Instance %s stopped gracefully", instanceID)
}
}