Files
mtusi2026lab4/cmd/messenger/main.go
T

216 lines
6.6 KiB
Go

package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"io"
"log/slog"
"net"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/config"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/logger"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/messenger"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/objectstore"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/password"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/reconcile"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/session"
)
func main() {
appLogger := logger.New()
if err := run(appLogger, os.Args[1:]); err != nil {
appLogger.Error("server stopped", "error", err)
os.Exit(1)
}
}
func run(logger *slog.Logger, arguments []string) error {
if len(arguments) == 0 {
return runServer(logger)
}
if len(arguments) == 1 && arguments[0] == "migrate" {
return runMigrations()
}
if len(arguments) > 0 && arguments[0] == "reconcile-attachments" {
return runAttachmentReconciliation(arguments[1:], os.Stdout)
}
return fmt.Errorf("usage: messenger [migrate|reconcile-attachments]")
}
func runServer(logger *slog.Logger) error {
settings, err := config.Load()
if err != nil {
return err
}
instanceID, err := os.Hostname()
if err != nil {
return err
}
pool, err := database.Open(context.Background(), database.Config{
URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns,
MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle,
HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout,
})
if err != nil {
return err
}
defer pool.Close()
sessions, err := session.New(settings.CacheURL)
if err != nil {
return err
}
defer func() { _ = sessions.Close() }()
passwords, err := password.New(password.Config{
MemoryKiB: settings.PasswordMemoryKiB, Iterations: settings.PasswordIterations,
Parallelism: settings.PasswordParallelism, SaltLength: settings.PasswordSaltLength,
KeyLength: settings.PasswordKeyLength,
})
if err != nil {
return err
}
objects, err := objectstore.New(objectstore.Config{
Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket,
AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey,
UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout,
})
if err != nil {
return err
}
app := messenger.NewServer(
logger,
postgres.New(pool),
sessions,
passwords,
objects,
settings.SessionTTL,
settings.IdempotencyTTL,
settings.RequestTimeout,
instanceID,
settings.SwaggerPort,
settings.AttachmentMaxBytes,
settings.AttachmentMaxPixels,
settings.AttachmentDecodeMemory,
)
server := &http.Server{
Addr: settings.Address,
Handler: app.Handler(),
ReadHeaderTimeout: settings.HTTPReadHeaderTimeout,
ReadTimeout: settings.HTTPReadTimeout,
WriteTimeout: settings.HTTPWriteTimeout,
IdleTimeout: settings.HTTPIdleTimeout,
}
listener, err := net.Listen("tcp", server.Addr)
if err != nil {
return err
}
serveResult := make(chan error, 1)
go func() {
serveResult <- server.Serve(listener)
}()
logger.Info("server started", "address", server.Addr)
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
select {
case err := <-serveResult:
return err
case <-ctx.Done():
logger.Info("shutdown requested")
app.SetReady(false)
shutdownCtx, cancel := context.WithTimeout(context.Background(), settings.HTTPShutdownTimeout)
defer cancel()
if err := server.Shutdown(shutdownCtx); err != nil {
_ = server.Close()
return err
}
return nil
}
}
func runMigrations() error {
settings, err := config.LoadMigration()
if err != nil {
return err
}
pool, err := database.Open(context.Background(), database.Config{
URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns,
MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle,
HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout,
})
if err != nil {
return err
}
defer pool.Close()
return database.Migrate(context.Background(), pool, settings.MigrationTimeout)
}
type reconciliationOutput struct {
Mode string `json:"mode"`
GracePeriod string `json:"grace_period"`
PageSize int `json:"page_size"`
DurationMillis int64 `json:"duration_ms"`
Report reconcile.Report `json:"report"`
}
func runAttachmentReconciliation(arguments []string, output io.Writer) error {
flags := flag.NewFlagSet("reconcile-attachments", flag.ContinueOnError)
flags.SetOutput(io.Discard)
apply := flags.Bool("apply", false, "apply safe repairs")
gracePeriod := flags.Duration("grace-period", time.Hour, "minimum anomaly age")
pageSize := flags.Int("page-size", 500, "S3 and PostgreSQL page size")
if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 {
return fmt.Errorf("usage: messenger reconcile-attachments [--apply] [--grace-period=1h] [--page-size=500]")
}
settings, err := config.Load()
if err != nil {
return err
}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
pool, err := database.Open(ctx, database.Config{
URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns,
MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle,
HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout,
})
if err != nil {
return err
}
defer pool.Close()
objects, err := objectstore.New(objectstore.Config{
Endpoint: settings.S3Endpoint, Region: settings.S3Region, Bucket: settings.S3Bucket,
AccessKey: settings.S3AccessKey, SecretKey: settings.S3SecretKey,
UseTLS: settings.S3UseTLS, Timeout: settings.S3Timeout,
})
if err != nil {
return err
}
reconciler, err := reconcile.New(postgres.New(pool), objects, reconcile.Config{
Prefix: "attachments/", PageSize: *pageSize, GraceTime: *gracePeriod, Apply: *apply,
})
if err != nil {
return err
}
started := time.Now()
report, err := reconciler.Run(ctx)
if err != nil {
return err
}
mode := "dry-run"
if *apply {
mode = "apply"
}
return json.NewEncoder(output).Encode(reconciliationOutput{
Mode: mode, GracePeriod: gracePeriod.String(), PageSize: *pageSize,
DurationMillis: time.Since(started).Milliseconds(), Report: report,
})
}