From 872b69f90ec7b95dd36964ffd2ebb799f4d89333 Mon Sep 17 00:00:00 2001 From: dizi Date: Thu, 24 Sep 2026 10:50:20 +0300 Subject: [PATCH 1/5] feat: add PostgreSQL persistence and sessions --- cmd/messenger/main.go | 91 ++++++ go.mod | 29 ++ go.sum | 75 +++++ internal/config/config.go | 148 +++++++++ internal/database/database.go | 81 +++++ internal/database/migrations.go | 150 +++++++++ internal/messenger/dependencies.go | 33 ++ internal/messenger/errors.go | 60 ++++ internal/messenger/handlers.go | 357 ++++++++++++++++++++++ internal/messenger/metrics.go | 75 +++++ internal/messenger/model.go | 29 ++ internal/messenger/request.go | 116 +++++++ internal/messenger/routes.go | 41 +++ internal/messenger/server.go | 102 +++++++ internal/model/model.go | 79 +++++ internal/password/password.go | 100 ++++++ internal/postgres/errors.go | 10 + internal/postgres/store.go | 469 +++++++++++++++++++++++++++++ internal/session/session.go | 161 ++++++++++ migrations/0001_initial.sql | 50 +++ migrations/embed.go | 8 + 21 files changed, 2264 insertions(+) create mode 100644 cmd/messenger/main.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/config/config.go create mode 100644 internal/database/database.go create mode 100644 internal/database/migrations.go create mode 100644 internal/messenger/dependencies.go create mode 100644 internal/messenger/errors.go create mode 100644 internal/messenger/handlers.go create mode 100644 internal/messenger/metrics.go create mode 100644 internal/messenger/model.go create mode 100644 internal/messenger/request.go create mode 100644 internal/messenger/routes.go create mode 100644 internal/messenger/server.go create mode 100644 internal/model/model.go create mode 100644 internal/password/password.go create mode 100644 internal/postgres/errors.go create mode 100644 internal/postgres/store.go create mode 100644 internal/session/session.go create mode 100644 migrations/0001_initial.sql create mode 100644 migrations/embed.go diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go new file mode 100644 index 0000000..0754e73 --- /dev/null +++ b/cmd/messenger/main.go @@ -0,0 +1,91 @@ +package main + +import ( + "context" + "log/slog" + "net" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/config" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/messenger" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/password" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" +) + +func main() { + logger := slog.New(slog.NewJSONHandler(os.Stdout, nil)) + if err := run(logger); err != nil { + logger.Error("server stopped", "error", err) + os.Exit(1) + } +} + +func run(logger *slog.Logger) error { + settings, err := config.Load() + if err != nil { + return err + } + pool, err := database.Open(context.Background(), database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: 30 * time.Minute, MaxConnectionIdle: 5 * time.Minute, + HealthCheckPeriod: 30 * time.Second, ConnectTimeout: settings.ConnectTimeout, + MigrationTimeout: 30 * time.Second, + }) + if err != nil { + return err + } + defer pool.Close() + sessions, err := session.New(settings.CacheURL) + if err != nil { + return err + } + defer func() { _ = sessions.Close() }() + app := messenger.NewServer( + logger, + postgres.New(pool), + sessions, + password.Hasher{}, + settings.SessionTTL, + settings.RequestTimeout, + settings.SwaggerPort, + ) + server := &http.Server{ + Addr: settings.Address, + Handler: app.Handler(), + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 10 * time.Second, + WriteTimeout: settings.RequestTimeout + 5*time.Second, + IdleTimeout: 60 * time.Second, + } + 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(), 10*time.Second) + defer cancel() + if err := server.Shutdown(shutdownCtx); err != nil { + _ = server.Close() + return err + } + return nil + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..c773449 --- /dev/null +++ b/go.mod @@ -0,0 +1,29 @@ +module gitea.privcloud.tech/dizi/mtusi2026lab2 + +go 1.26.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.11.0 + github.com/prometheus/client_golang v1.23.2 + github.com/valkey-io/valkey-go v1.0.78 + golang.org/x/crypto v0.57.0 +) + +require ( + github.com/beorn7/perks v1.0.1 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/kr/text v0.2.0 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.66.1 // indirect + github.com/prometheus/procfs v0.16.1 // indirect + go.yaml.in/yaml/v2 v2.4.2 // indirect + golang.org/x/sync v0.23.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/text v0.42.0 // indirect + google.golang.org/protobuf v1.36.8 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..e2cb534 --- /dev/null +++ b/go.sum @@ -0,0 +1,75 @@ +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/onsi/gomega v1.42.1 h1:iN1rCUX+44NZ1Dc97MPoeFYbFR0vh8zxoxMFwKdyZ6I= +github.com/onsi/gomega v1.42.1/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs= +github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA= +github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= +github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= +github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= +github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/valkey-io/valkey-go v1.0.78 h1:1Ce8hRaaNXpKfqmqZQRhnbVh1eW8MGR873pdXVvE4y8= +github.com/valkey-io/valkey-go v1.0.78/go.mod h1:gvC/r2m3eW4Hbj0YnjogTzNtFdPSM/D+NCqen+5OABM= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= +go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M= +golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= +golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= +google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc= +google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 0000000..644cad8 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,148 @@ +package config + +import ( + "errors" + "fmt" + "net" + "os" + "strconv" + "strings" + "time" +) + +type Config struct { + Address string + DatabaseURL string + CacheURL string + SessionTTL time.Duration + DBMaxConns int32 + DBMinConns int32 + ConnectTimeout time.Duration + RequestTimeout time.Duration + SwaggerPort string +} + +func Load() (Config, error) { + host, err := requiredEnv("APP_HOST") + if err != nil { + return Config{}, err + } + port, err := requiredPort("APP_PORT") + if err != nil { + return Config{}, err + } + databaseURL, err := secretFromEnv("DATABASE_URL_FILE") + if err != nil { + return Config{}, err + } + cacheURL, err := secretFromEnv("CACHE_URL_FILE") + if err != nil { + return Config{}, err + } + if store, err := requiredEnv("SESSION_STORE"); err != nil { + return Config{}, err + } else if store != "valkey" { + return Config{}, errors.New("SESSION_STORE must be valkey") + } + ttlSeconds, err := requiredPositiveInt("SESSION_TTL_SECONDS") + if err != nil { + return Config{}, err + } + maxConns, err := intEnv("DB_MAX_CONNS", 10, 1, 100) + if err != nil { + return Config{}, err + } + minConns, err := intEnv("DB_MIN_CONNS", 1, 0, maxConns) + if err != nil { + return Config{}, err + } + connectSeconds, err := intEnv("DEPENDENCY_TIMEOUT_SECONDS", 5, 1, 60) + if err != nil { + return Config{}, err + } + swaggerPort := os.Getenv("SWAGGER_PORT") + if swaggerPort == "" { + swaggerPort = "8081" + } + if _, err := parsePort(swaggerPort); err != nil { + return Config{}, fmt.Errorf("SWAGGER_PORT: %w", err) + } + return Config{ + Address: net.JoinHostPort(host, port), + DatabaseURL: databaseURL, + CacheURL: cacheURL, + SessionTTL: time.Duration(ttlSeconds) * time.Second, + DBMaxConns: int32(maxConns), + DBMinConns: int32(minConns), + ConnectTimeout: time.Duration(connectSeconds) * time.Second, + RequestTimeout: time.Duration(connectSeconds) * time.Second, + SwaggerPort: swaggerPort, + }, nil +} + +func requiredEnv(name string) (string, error) { + value := strings.TrimSpace(os.Getenv(name)) + if value == "" { + return "", fmt.Errorf("%s is required", name) + } + return value, nil +} + +func requiredPort(name string) (string, error) { + value, err := requiredEnv(name) + if err != nil { + return "", err + } + if _, err := parsePort(value); err != nil { + return "", fmt.Errorf("%s: %w", name, err) + } + return value, nil +} + +func parsePort(value string) (int, error) { + port, err := strconv.Atoi(value) + if err != nil || port < 1 || port > 65535 { + return 0, errors.New("must be between 1 and 65535") + } + return port, nil +} + +func requiredPositiveInt(name string) (int, error) { + value, err := requiredEnv(name) + if err != nil { + return 0, err + } + parsed, err := strconv.Atoi(value) + if err != nil || parsed <= 0 { + return 0, fmt.Errorf("%s must be a positive integer", name) + } + return parsed, nil +} + +func intEnv(name string, fallback, minimum, maximum int) (int, error) { + value := os.Getenv(name) + if value == "" { + return fallback, nil + } + parsed, err := strconv.Atoi(value) + if err != nil || parsed < minimum || parsed > maximum { + return 0, fmt.Errorf("%s must be between %d and %d", name, minimum, maximum) + } + return parsed, nil +} + +func secretFromEnv(name string) (string, error) { + path, err := requiredEnv(name) + if err != nil { + return "", err + } + data, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("read %s: %w", name, err) + } + value := strings.TrimSpace(string(data)) + if value == "" { + return "", fmt.Errorf("%s points to an empty file", name) + } + return value, nil +} diff --git a/internal/database/database.go b/internal/database/database.go new file mode 100644 index 0000000..10b0eda --- /dev/null +++ b/internal/database/database.go @@ -0,0 +1,81 @@ +package database + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/migrations" +) + +type Config struct { + URL string + MinConnections int32 + MaxConnections int32 + MaxConnectionAge time.Duration + MaxConnectionIdle time.Duration + HealthCheckPeriod time.Duration + ConnectTimeout time.Duration + MigrationTimeout time.Duration +} + +func Open(ctx context.Context, config Config) (*pgxpool.Pool, error) { + if err := validateConfig(config); err != nil { + return nil, err + } + poolConfig, err := pgxpool.ParseConfig(config.URL) + if err != nil { + return nil, fmt.Errorf("parse database configuration: %w", err) + } + poolConfig.MinConns = config.MinConnections + poolConfig.MaxConns = config.MaxConnections + poolConfig.MaxConnLifetime = config.MaxConnectionAge + poolConfig.MaxConnIdleTime = config.MaxConnectionIdle + poolConfig.HealthCheckPeriod = config.HealthCheckPeriod + + connectCtx, cancel := context.WithTimeout(ctx, config.ConnectTimeout) + defer cancel() + pool, err := pgxpool.NewWithConfig(connectCtx, poolConfig) + if err != nil { + return nil, fmt.Errorf("create database pool: %w", err) + } + if err := pool.Ping(connectCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping database: %w", err) + } + + migrationCtx, cancel := context.WithTimeout(ctx, config.MigrationTimeout) + defer cancel() + if err := applyMigrations(migrationCtx, pool, migrations.FS); err != nil { + pool.Close() + return nil, err + } + return pool, nil +} + +func validateConfig(config Config) error { + switch { + case config.URL == "": + return fmt.Errorf("database URL is required") + case config.MinConnections < 0: + return fmt.Errorf("minimum database connections must not be negative") + case config.MaxConnections < 1: + return fmt.Errorf("maximum database connections must be positive") + case config.MinConnections > config.MaxConnections: + return fmt.Errorf("minimum database connections exceed maximum") + case config.MaxConnectionAge <= 0: + return fmt.Errorf("maximum database connection age must be positive") + case config.MaxConnectionIdle <= 0: + return fmt.Errorf("maximum database connection idle time must be positive") + case config.HealthCheckPeriod <= 0: + return fmt.Errorf("database health check period must be positive") + case config.ConnectTimeout <= 0: + return fmt.Errorf("database connection timeout must be positive") + case config.MigrationTimeout <= 0: + return fmt.Errorf("database migration timeout must be positive") + default: + return nil + } +} diff --git a/internal/database/migrations.go b/internal/database/migrations.go new file mode 100644 index 0000000..095c93d --- /dev/null +++ b/internal/database/migrations.go @@ -0,0 +1,150 @@ +package database + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "io/fs" + "path/filepath" + "regexp" + "sort" + "strconv" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +const ( + migrationLockID int64 = 0x4d54555349324c42 + migrationUnlockTimeout = 5 * time.Second +) + +var migrationNamePattern = regexp.MustCompile(`^(\d+)_([a-z0-9_]+)\.sql$`) + +type migration struct { + version int64 + name string + checksum string + sql string +} + +func applyMigrations(ctx context.Context, pool *pgxpool.Pool, migrationFS fs.FS) (returnErr error) { + migrations, err := readMigrations(migrationFS) + if err != nil { + return err + } + connection, err := pool.Acquire(ctx) + if err != nil { + return fmt.Errorf("acquire connection for migrations: %w", err) + } + defer connection.Release() + if _, err := connection.Exec(ctx, "SELECT pg_advisory_lock($1)", migrationLockID); err != nil { + return fmt.Errorf("lock migrations: %w", err) + } + defer func() { + unlockCtx, cancel := context.WithTimeout(context.Background(), migrationUnlockTimeout) + defer cancel() + if _, err := connection.Exec(unlockCtx, "SELECT pg_advisory_unlock($1)", migrationLockID); err != nil { + _ = connection.Conn().Close(unlockCtx) + if returnErr == nil { + returnErr = fmt.Errorf("unlock migrations: %w", err) + } + } + }() + + if _, err := connection.Exec(ctx, ` +CREATE TABLE IF NOT EXISTS schema_migrations ( + version BIGINT PRIMARY KEY, + name TEXT NOT NULL, + checksum TEXT NOT NULL, + applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp() +)`); err != nil { + return fmt.Errorf("create migration history: %w", err) + } + for _, migration := range migrations { + if err := applyMigration(ctx, connection, migration); err != nil { + return err + } + } + return nil +} + +func readMigrations(migrationFS fs.FS) ([]migration, error) { + entries, err := fs.ReadDir(migrationFS, ".") + if err != nil { + return nil, fmt.Errorf("read embedded migrations: %w", err) + } + migrations := make([]migration, 0, len(entries)) + versions := make(map[int64]string) + for _, entry := range entries { + if entry.IsDir() || filepath.Ext(entry.Name()) != ".sql" { + continue + } + matches := migrationNamePattern.FindStringSubmatch(entry.Name()) + if matches == nil { + return nil, fmt.Errorf("invalid migration filename %q", entry.Name()) + } + version, err := strconv.ParseInt(matches[1], 10, 64) + if err != nil || version < 1 { + return nil, fmt.Errorf("invalid migration version in %q", entry.Name()) + } + if previous, exists := versions[version]; exists { + return nil, fmt.Errorf("migration version %d is used by %q and %q", version, previous, entry.Name()) + } + data, err := fs.ReadFile(migrationFS, entry.Name()) + if err != nil { + return nil, fmt.Errorf("read migration %q: %w", entry.Name(), err) + } + hash := sha256.Sum256(data) + versions[version] = entry.Name() + migrations = append(migrations, migration{ + version: version, + name: entry.Name(), + checksum: hex.EncodeToString(hash[:]), + sql: string(data), + }) + } + if len(migrations) == 0 { + return nil, errors.New("no database migrations found") + } + sort.Slice(migrations, func(i, j int) bool { + return migrations[i].version < migrations[j].version + }) + return migrations, nil +} + +func applyMigration(ctx context.Context, connection *pgxpool.Conn, migration migration) error { + var checksum string + err := connection.QueryRow(ctx, "SELECT checksum FROM schema_migrations WHERE version = $1", migration.version).Scan(&checksum) + switch { + case err == nil && checksum != migration.checksum: + return fmt.Errorf("migration %q checksum does not match applied version", migration.name) + case err == nil: + return nil + case !errors.Is(err, pgx.ErrNoRows): + return fmt.Errorf("read migration %q state: %w", migration.name, err) + } + + transaction, err := connection.Begin(ctx) + if err != nil { + return fmt.Errorf("begin migration %q: %w", migration.name, err) + } + defer func() { + _ = transaction.Rollback(context.WithoutCancel(ctx)) + }() + if _, err := transaction.Exec(ctx, migration.sql, pgx.QueryExecModeSimpleProtocol); err != nil { + return fmt.Errorf("apply migration %q: %w", migration.name, err) + } + if _, err := transaction.Exec(ctx, ` +INSERT INTO schema_migrations (version, name, checksum) +VALUES ($1, $2, $3)`, migration.version, migration.name, migration.checksum); err != nil { + return fmt.Errorf("record migration %q: %w", migration.name, err) + } + if err := transaction.Commit(ctx); err != nil { + return fmt.Errorf("commit migration %q: %w", migration.name, err) + } + return nil +} diff --git a/internal/messenger/dependencies.go b/internal/messenger/dependencies.go new file mode 100644 index 0000000..f2fbadd --- /dev/null +++ b/internal/messenger/dependencies.go @@ -0,0 +1,33 @@ +package messenger + +import ( + "context" + "time" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" +) + +type Repository interface { + Ping(context.Context) error + CreateUser(context.Context, string, string, string) (model.User, error) + UserByID(context.Context, string) (model.User, error) + UserByUsername(context.Context, string) (model.UserCredentials, error) + CreateChat(context.Context, string, []string, string) (model.Chat, error) + ChatForUser(context.Context, string, string) (model.Chat, error) + ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) + CreateMessage(context.Context, string, string, string) (model.Message, error) + ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) +} + +type SessionStore interface { + Ping(context.Context) error + Create(context.Context, string, time.Duration) (string, time.Time, error) + UserID(context.Context, string) (string, error) + Delete(context.Context, string) error +} + +type Passwords interface { + Hash(string) (string, error) + Verify(string, string) (bool, error) + DummyHash() string +} diff --git a/internal/messenger/errors.go b/internal/messenger/errors.go new file mode 100644 index 0000000..88d2970 --- /dev/null +++ b/internal/messenger/errors.go @@ -0,0 +1,60 @@ +package messenger + +import ( + "encoding/json" + "net/http" +) + +const ( + errorCodeInvalidRequest = "invalid_request" + errorCodeUnauthorized = "unauthorized" + errorCodeNotFound = "not_found" + errorCodeInternal = "internal_error" + errorCodeUnsupportedMediaType = "unsupported_media_type" + errorCodePayloadTooLarge = "payload_too_large" + errorCodeUnavailable = "unavailable" + errorCodeConflict = "conflict" +) + +type apiError struct { + status int + code string + message string +} + +func methodNotAllowed(w http.ResponseWriter, allowed string) *apiError { + w.Header().Set("Allow", allowed) + return &apiError{http.StatusMethodNotAllowed, errorCodeInvalidRequest, "method not allowed"} +} + +func invalidRequest() *apiError { + return &apiError{http.StatusBadRequest, errorCodeInvalidRequest, "invalid request"} +} + +func unauthorized() *apiError { + return &apiError{http.StatusUnauthorized, errorCodeUnauthorized, "authentication required"} +} + +func notFound() *apiError { + return &apiError{http.StatusNotFound, errorCodeNotFound, "resource not found"} +} + +func internalError() *apiError { + return &apiError{http.StatusInternalServerError, errorCodeInternal, "internal server error"} +} + +func unavailable() *apiError { + return &apiError{http.StatusServiceUnavailable, errorCodeUnavailable, "service unavailable"} +} + +func writeError(w http.ResponseWriter, requestID string, err *apiError) { + writeJSON(w, err.status, map[string]any{"error": map[string]string{ + "code": err.code, "message": err.message, "request_id": requestID, + }}) +} + +func writeJSON(w http.ResponseWriter, status int, value any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(value) +} diff --git a/internal/messenger/handlers.go b/internal/messenger/handlers.go new file mode 100644 index 0000000..0100db7 --- /dev/null +++ b/internal/messenger/handlers.go @@ -0,0 +1,357 @@ +package messenger + +import ( + "context" + "errors" + "io" + "net/http" + "regexp" + "strings" + "time" + "unicode/utf8" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +func (s *Server) live(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) + return nil +} + +func (s *Server) readiness(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + if !s.ready.Load() { + return unavailable() + } + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + defer cancel() + if err := s.repository.Ping(ctx); err != nil { + return unavailable() + } + if err := s.sessions.Ping(ctx); err != nil { + return unavailable() + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) + return nil +} + +func (s *Server) users(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + var input struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if err := readJSON(w, r, &input); err != nil { + return err + } + if !usernamePattern.MatchString(input.Username) || !validText(input.DisplayName, 100) || !validPassword(input.Password) { + return invalidRequest() + } + passwordHash, err := s.passwords.Hash(input.Password) + if err != nil { + return internalError() + } + user, err := s.repository.CreateUser(r.Context(), input.Username, input.DisplayName, passwordHash) + if errors.Is(err, postgres.ErrConflict) { + return &apiError{http.StatusConflict, errorCodeConflict, "username already exists"} + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, user) + return nil +} + +func validPassword(value string) bool { + length := utf8.RuneCountInString(value) + return utf8.ValidString(value) && strings.TrimSpace(value) != "" && length >= 12 && length <= 128 +} + +func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + body, err := io.ReadAll(io.LimitReader(r.Body, 1)) + if err != nil || len(body) != 0 { + return invalidRequest() + } + username, passwordValue, ok := singleBasicAuth(r) + if !ok { + return unauthorized() + } + credentials, err := s.repository.UserByUsername(r.Context(), username) + if errors.Is(err, postgres.ErrNotFound) { + if _, verifyErr := s.passwords.Verify(passwordValue, s.passwords.DummyHash()); verifyErr != nil { + return internalError() + } + return unauthorized() + } + if err != nil { + return unavailable() + } + verified, err := s.passwords.Verify(passwordValue, credentials.PasswordHash) + if err != nil { + return internalError() + } + if !verified { + return unauthorized() + } + token, expiresAt, err := s.sessions.Create(r.Context(), credentials.ID, s.sessionTTL) + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User User `json:"user"` + }{token, "Bearer", model.FormatTime(expiresAt), credentials.User}) + return nil +} + +func singleBasicAuth(r *http.Request) (string, string, bool) { + if len(r.Header.Values("Authorization")) != 1 { + return "", "", false + } + username, passwordValue, ok := r.BasicAuth() + return username, passwordValue, ok && username != "" +} + +func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodDelete { + return methodNotAllowed(w, http.MethodDelete) + } + _, token, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + if err := s.sessions.Delete(r.Context(), token); errors.Is(err, session.ErrNotFound) { + return unauthorized() + } else if err != nil { + return unavailable() + } + w.WriteHeader(http.StatusNoContent) + return nil +} + +func (s *Server) me(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, err := s.authenticate(r) + if err != nil { + return err + } + writeJSON(w, http.StatusOK, user) + return nil +} + +func (s *Server) chats(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost && r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet+", "+http.MethodPost) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + if r.Method == http.MethodGet { + return s.listChats(w, r, user) + } + var input struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if err := readJSON(w, r, &input); err != nil { + return err + } + if !validText(input.Title, 100) || len(input.MemberIDs) < 1 || len(input.MemberIDs) > 100 { + return invalidRequest() + } + members := make(map[string]struct{}, len(input.MemberIDs)) + for i, memberID := range input.MemberIDs { + canonical, valid := canonicalID(memberID) + if !valid { + return invalidRequest() + } + if _, duplicate := members[canonical]; duplicate { + return invalidRequest() + } + members[canonical] = struct{}{} + input.MemberIDs[i] = canonical + } + if _, included := members[user.ID]; !included { + return invalidRequest() + } + chat, err := s.repository.CreateChat(r.Context(), input.Title, input.MemberIDs, user.ID) + if errors.Is(err, postgres.ErrInvalidMembers) { + return invalidRequest() + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, chat) + return nil +} + +func (s *Server) listChats(w http.ResponseWriter, r *http.Request, user User) *apiError { + limit, cursor, err := pageParams(r, "chat", user.ID) + if err != nil { + return err + } + items, hasNext, listErr := s.repository.ListChats(r.Context(), user.ID, cursorPosition(cursor), limit) + if errors.Is(listErr, postgres.ErrInvalidCursor) { + return invalidRequest() + } + if listErr != nil { + return unavailable() + } + if items == nil { + items = []Chat{} + } + var next *string + if hasNext { + last := items[len(items)-1] + value := encodeCursor("chat", user.ID, last.CreatedAt, last.ID) + next = &value + } + writeJSON(w, http.StatusOK, struct { + Items []Chat `json:"items"` + NextCursor *string `json:"next_cursor"` + }{items, next}) + return nil +} + +func (s *Server) chat(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) + if !valid { + return invalidRequest() + } + chat, err := s.repository.ChatForUser(r.Context(), chatID, user.ID) + if errors.Is(err, postgres.ErrNotFound) { + return notFound() + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusOK, chat) + return nil +} + +func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost && r.Method != http.MethodGet { + return methodNotAllowed(w, http.MethodGet+", "+http.MethodPost) + } + user, _, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + chatID, valid := canonicalID(strings.Split(r.URL.Path, "/")[4]) + if !valid { + return invalidRequest() + } + if r.Method == http.MethodGet { + return s.listMessages(w, r, user, chatID) + } + var input struct { + Text string `json:"text"` + } + if err := readJSON(w, r, &input); err != nil { + return err + } + if !validText(input.Text, 4000) { + return invalidRequest() + } + message, err := s.repository.CreateMessage(r.Context(), chatID, user.ID, input.Text) + if errors.Is(err, postgres.ErrNotFound) { + return notFound() + } + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, message) + return nil +} + +func (s *Server) listMessages(w http.ResponseWriter, r *http.Request, user User, chatID string) *apiError { + limit, cursor, err := pageParams(r, "message", chatID) + if err != nil { + return err + } + items, hasNext, listErr := s.repository.ListMessages(r.Context(), chatID, user.ID, cursorPosition(cursor), limit) + if errors.Is(listErr, postgres.ErrNotFound) { + return notFound() + } + if errors.Is(listErr, postgres.ErrInvalidCursor) { + return invalidRequest() + } + if listErr != nil { + return unavailable() + } + if items == nil { + items = []Message{} + } + var next *string + if hasNext { + last := items[len(items)-1] + value := encodeCursor("message", chatID, last.CreatedAt, last.ID) + next = &value + } + writeJSON(w, http.StatusOK, struct { + Items []Message `json:"items"` + NextCursor *string `json:"next_cursor"` + }{items, next}) + return nil +} + +func cursorPosition(cursor *pageCursor) *model.Position { + if cursor == nil { + return nil + } + return &model.Position{CreatedAt: cursor.Time, ID: cursor.ID} +} + +func (s *Server) authenticate(r *http.Request) (User, string, *apiError) { + values := r.Header.Values("Authorization") + if len(values) != 1 { + return User{}, "", unauthorized() + } + scheme, token, found := strings.Cut(values[0], " ") + if !found || !strings.EqualFold(scheme, "Bearer") || token == "" || strings.ContainsAny(token, " \t\r\n") { + return User{}, "", unauthorized() + } + userID, err := s.sessions.UserID(r.Context(), token) + if errors.Is(err, session.ErrNotFound) || errors.Is(err, session.ErrInvalidToken) { + return User{}, "", unauthorized() + } + if err != nil { + return User{}, "", unavailable() + } + user, err := s.repository.UserByID(r.Context(), userID) + if errors.Is(err, postgres.ErrNotFound) { + _ = s.sessions.Delete(r.Context(), token) + return User{}, "", unauthorized() + } + if err != nil { + return User{}, "", unavailable() + } + return user, token, nil +} diff --git a/internal/messenger/metrics.go b/internal/messenger/metrics.go new file mode 100644 index 0000000..1f6272d --- /dev/null +++ b/internal/messenger/metrics.go @@ -0,0 +1,75 @@ +package messenger + +import ( + "net/http" + "strconv" + "strings" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/collectors" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +type metrics struct { + requests *prometheus.CounterVec + duration *prometheus.HistogramVec + inFlight prometheus.Gauge + handler http.Handler +} + +func newMetrics() *metrics { + registry := prometheus.NewRegistry() + result := &metrics{ + requests: prometheus.NewCounterVec(prometheus.CounterOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "requests_total", + Help: "Completed HTTP requests.", + }, []string{"method", "route", "status_class"}), + duration: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "request_duration_seconds", + Help: "HTTP request duration in seconds.", + Buckets: prometheus.DefBuckets, + }, []string{"method", "route"}), + inFlight: prometheus.NewGauge(prometheus.GaugeOpts{ + Namespace: "messenger", + Subsystem: "http", + Name: "requests_in_flight", + Help: "HTTP requests currently being served.", + }), + } + registry.MustRegister( + result.requests, + result.duration, + result.inFlight, + collectors.NewGoCollector(), + collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}), + ) + result.handler = promhttp.HandlerFor(registry, promhttp.HandlerOpts{}) + return result +} + +func (m *metrics) observe(r *http.Request, status int, started time.Time) { + route := routeTemplate(r.URL.Path) + m.requests.WithLabelValues(r.Method, route, strconv.Itoa(status/100)+"xx").Inc() + m.duration.WithLabelValues(r.Method, route).Observe(time.Since(started).Seconds()) +} + +func routeTemplate(path string) string { + switch path { + case "/health/live", "/health/ready", "/metrics", "/api/v1/users", "/api/v1/users/me", + "/api/v1/auth/sessions", "/api/v1/auth/sessions/current", "/api/v1/chats": + return path + } + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) == 4 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" { + return "/api/v1/chats/{chat_id}" + } + if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "messages" { + return "/api/v1/chats/{chat_id}/messages" + } + return "unknown" +} diff --git a/internal/messenger/model.go b/internal/messenger/model.go new file mode 100644 index 0000000..65474b6 --- /dev/null +++ b/internal/messenger/model.go @@ -0,0 +1,29 @@ +package messenger + +import ( + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" + "github.com/google/uuid" +) + +type User = model.User +type Chat = model.Chat +type Message = model.Message + +func newID() (string, error) { + id, err := uuid.NewRandom() + if err != nil { + return "", err + } + return id.String(), nil +} + +func canonicalID(value string) (string, bool) { + if len(value) != 36 { + return "", false + } + id, err := uuid.Parse(value) + if err != nil { + return "", false + } + return id.String(), true +} diff --git a/internal/messenger/request.go b/internal/messenger/request.go new file mode 100644 index 0000000..8b9a7cc --- /dev/null +++ b/internal/messenger/request.go @@ -0,0 +1,116 @@ +package messenger + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "errors" + "io" + "mime" + "net/http" + "net/url" + "strconv" + "strings" + "time" + "unicode/utf8" +) + +const maxRequestBytes = 1 << 20 + +func readJSON(w http.ResponseWriter, r *http.Request, target any) *apiError { + mediaType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil || mediaType != "application/json" || (params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) { + return &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "expected application/json"} + } + r.Body = http.MaxBytesReader(w, r.Body, maxRequestBytes) + data, err := io.ReadAll(r.Body) + if err != nil { + var tooLarge *http.MaxBytesError + if errors.As(err, &tooLarge) { + return &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "request body too large"} + } + return invalidRequest() + } + if !utf8.Valid(data) { + return invalidRequest() + } + var object map[string]json.RawMessage + if err := json.Unmarshal(data, &object); err != nil || object == nil { + return invalidRequest() + } + normalized, err := json.Marshal(object) + if err != nil { + return invalidRequest() + } + decoder := json.NewDecoder(bytes.NewReader(normalized)) + decoder.DisallowUnknownFields() + if err := decoder.Decode(target); err != nil { + return invalidRequest() + } + return nil +} + +func validText(value string, maxRunes int) bool { + return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= maxRunes +} + +type pageCursor struct { + Kind string `json:"kind"` + Resource string `json:"resource"` + Time time.Time `json:"time"` + ID string `json:"id"` +} + +func pageParams(r *http.Request, kind, resource string) (int, *pageCursor, *apiError) { + query, err := url.ParseQuery(r.URL.RawQuery) + if err != nil { + return 0, nil, invalidRequest() + } + for key := range query { + if key != "limit" && key != "cursor" { + return 0, nil, invalidRequest() + } + if len(query[key]) != 1 { + return 0, nil, invalidRequest() + } + } + limit := 50 + if value, present := query["limit"]; present { + parsed, err := strconv.Atoi(value[0]) + if err != nil || parsed < 1 || parsed > 100 { + return 0, nil, invalidRequest() + } + limit = parsed + } + if value, present := query["cursor"]; present { + cursor, valid := decodeCursor(value[0], kind, resource) + if !valid { + return 0, nil, invalidRequest() + } + return limit, cursor, nil + } + return limit, nil, nil +} + +func encodeCursor(kind, resource string, createdAt time.Time, id string) string { + data, _ := json.Marshal(pageCursor{kind, resource, createdAt, id}) + return base64.RawURLEncoding.EncodeToString(data) +} + +func decodeCursor(value, kind, resource string) (*pageCursor, bool) { + data, err := base64.RawURLEncoding.DecodeString(value) + if err != nil { + return nil, false + } + var cursor pageCursor + if err := json.Unmarshal(data, &cursor); err != nil || cursor.Kind != kind || cursor.Resource != resource { + return nil, false + } + if cursor.Time.IsZero() { + return nil, false + } + if _, valid := canonicalID(cursor.ID); !valid { + return nil, false + } + return &cursor, true +} diff --git a/internal/messenger/routes.go b/internal/messenger/routes.go new file mode 100644 index 0000000..bb698d0 --- /dev/null +++ b/internal/messenger/routes.go @@ -0,0 +1,41 @@ +package messenger + +import ( + "net/http" + "strings" +) + +type requestHandler func(http.ResponseWriter, *http.Request) *apiError + +func (s *Server) route(w http.ResponseWriter, r *http.Request) *apiError { + var handler requestHandler + switch r.URL.Path { + case "/health/live": + handler = s.live + case "/health/ready": + handler = s.readiness + case "/metrics": + s.metrics.handler.ServeHTTP(w, r) + return nil + case "/api/v1/users": + handler = s.users + case "/api/v1/users/me": + handler = s.me + case "/api/v1/auth/sessions": + handler = s.createSession + case "/api/v1/auth/sessions/current": + handler = s.revokeSession + case "/api/v1/chats": + handler = s.chats + default: + parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/") + if len(parts) == 4 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" { + handler = s.chat + } else if len(parts) == 5 && parts[0] == "api" && parts[1] == "v1" && parts[2] == "chats" && parts[4] == "messages" { + handler = s.messages + } else { + return notFound() + } + } + return handler(w, r) +} diff --git a/internal/messenger/server.go b/internal/messenger/server.go new file mode 100644 index 0000000..33a4fd7 --- /dev/null +++ b/internal/messenger/server.go @@ -0,0 +1,102 @@ +package messenger + +import ( + "context" + "log/slog" + "net/http" + "sync/atomic" + "time" +) + +type Server struct { + repository Repository + sessions SessionStore + passwords Passwords + sessionTTL time.Duration + requestTTL time.Duration + logger *slog.Logger + swaggerPort string + metrics *metrics + ready atomic.Bool +} + +type statusWriter struct { + http.ResponseWriter + status int +} + +func (w *statusWriter) WriteHeader(status int) { + w.status = status + w.ResponseWriter.WriteHeader(status) +} + +func NewServer(logger *slog.Logger, repository Repository, sessions SessionStore, passwords Passwords, sessionTTL, requestTTL time.Duration, swaggerPort string) *Server { + s := &Server{ + repository: repository, sessions: sessions, passwords: passwords, + sessionTTL: sessionTTL, requestTTL: requestTTL, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(), + } + s.ready.Store(true) + return s +} + +func (s *Server) SetReady(ready bool) { + s.ready.Store(ready) +} + +func (s *Server) Handler() http.Handler { + return http.HandlerFunc(s.serve) +} + +func (s *Server) serve(w http.ResponseWriter, r *http.Request) { + requestID, err := newID() + if err != nil { + http.Error(w, "server unavailable", http.StatusServiceUnavailable) + return + } + w.Header().Set("X-Request-Id", requestID) + w.Header().Set("Cache-Control", "no-store") + wrapped := &statusWriter{ResponseWriter: w, status: http.StatusOK} + started := time.Now() + s.metrics.inFlight.Inc() + defer func() { + s.metrics.inFlight.Dec() + if recovered := recover(); recovered != nil { + s.logger.Error("request panic", "request_id", requestID, "method", r.Method, "path", r.URL.Path) + if wrapped.status == http.StatusOK { + writeError(wrapped, requestID, internalError()) + } + } + s.metrics.observe(r, wrapped.status, started) + s.logger.Info("request", "request_id", requestID, "method", r.Method, "path", r.URL.Path, "status", wrapped.status, "duration_ms", time.Since(started).Milliseconds()) + }() + if s.allowSwaggerOrigin(wrapped, r) && r.Method == http.MethodOptions && r.Header.Get("Access-Control-Request-Method") != "" { + wrapped.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS") + wrapped.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type") + wrapped.WriteHeader(http.StatusNoContent) + return + } + ctx, cancel := context.WithTimeout(r.Context(), s.requestTTL) + defer cancel() + r = r.WithContext(ctx) + if apiErr := s.route(wrapped, r); apiErr != nil { + if apiErr.status == http.StatusUnauthorized { + challenge := `Bearer realm="messenger"` + if r.URL.Path == "/api/v1/auth/sessions" { + challenge = `Basic realm="messenger", charset="UTF-8"` + } + wrapped.Header().Set("WWW-Authenticate", challenge) + } + writeError(wrapped, requestID, apiErr) + } +} + +func (s *Server) allowSwaggerOrigin(w http.ResponseWriter, r *http.Request) bool { + origin := r.Header.Get("Origin") + if origin != "http://localhost:"+s.swaggerPort && origin != "http://127.0.0.1:"+s.swaggerPort { + return false + } + w.Header().Set("Access-Control-Allow-Origin", origin) + w.Header().Set("Access-Control-Expose-Headers", "X-Request-Id") + w.Header().Add("Vary", "Origin") + return true +} diff --git a/internal/model/model.go b/internal/model/model.go new file mode 100644 index 0000000..65a5edb --- /dev/null +++ b/internal/model/model.go @@ -0,0 +1,79 @@ +package model + +import ( + "encoding/json" + "time" +) + +const timestampLayout = "2006-01-02T15:04:05.000000Z" + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +type UserCredentials struct { + User + PasswordHash string `json:"-"` +} + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` +} + +type Position struct { + CreatedAt time.Time + ID string +} + +func (u User) MarshalJSON() ([]byte, error) { + type response struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` + } + return json.Marshal(response{u.ID, u.Username, u.DisplayName, formatTime(u.CreatedAt)}) +} + +func (c Chat) MarshalJSON() ([]byte, error) { + type response struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` + } + return json.Marshal(response{c.ID, c.Title, c.MemberIDs, formatTime(c.CreatedAt)}) +} + +func (m Message) MarshalJSON() ([]byte, error) { + type response struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` + } + return json.Marshal(response{m.ID, m.ChatID, m.SenderID, m.Text, formatTime(m.CreatedAt)}) +} + +func FormatTime(value time.Time) string { + return formatTime(value) +} + +func formatTime(value time.Time) string { + return value.UTC().Format(timestampLayout) +} diff --git a/internal/password/password.go b/internal/password/password.go new file mode 100644 index 0000000..e85b13e --- /dev/null +++ b/internal/password/password.go @@ -0,0 +1,100 @@ +package password + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "errors" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +const ( + MemoryKiB uint32 = 64 * 1024 + Iterations uint32 = 3 + Parallelism uint8 = 2 + SaltLength = 16 + KeyLength uint32 = 32 +) + +var ErrInvalidHash = errors.New("invalid password hash") + +var dummyHash = encode( + make([]byte, SaltLength), + argon2.IDKey([]byte("invalid-user-password"), make([]byte, SaltLength), Iterations, MemoryKiB, Parallelism, KeyLength), +) + +type Hasher struct{} + +func (Hasher) Hash(value string) (string, error) { + return Hash(value) +} + +func (Hasher) Verify(value, encodedHash string) (bool, error) { + return Verify(value, encodedHash) +} + +func (Hasher) DummyHash() string { + return dummyHash +} + +func Hash(value string) (string, error) { + salt := make([]byte, SaltLength) + if _, err := rand.Read(salt); err != nil { + return "", fmt.Errorf("generate password salt: %w", err) + } + + digest := argon2.IDKey([]byte(value), salt, Iterations, MemoryKiB, Parallelism, KeyLength) + + return encode(salt, digest), nil +} + +func encode(salt, digest []byte) string { + return fmt.Sprintf( + "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, + MemoryKiB, + Iterations, + Parallelism, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(digest), + ) +} + +func Verify(value, encodedHash string) (bool, error) { + salt, digest, err := decode(encodedHash) + if err != nil { + return false, err + } + + actual := argon2.IDKey([]byte(value), salt, Iterations, MemoryKiB, Parallelism, KeyLength) + return subtle.ConstantTimeCompare(actual, digest) == 1, nil +} + +func decode(encodedHash string) ([]byte, []byte, error) { + parts := strings.Split(encodedHash, "$") + if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" { + return nil, nil, ErrInvalidHash + } + + if parts[2] != fmt.Sprintf("v=%d", argon2.Version) { + return nil, nil, ErrInvalidHash + } + if parts[3] != fmt.Sprintf("m=%d,t=%d,p=%d", MemoryKiB, Iterations, Parallelism) { + return nil, nil, ErrInvalidHash + } + + salt, err := base64.RawStdEncoding.Strict().DecodeString(parts[4]) + if err != nil || len(salt) != SaltLength { + return nil, nil, ErrInvalidHash + } + + digest, err := base64.RawStdEncoding.Strict().DecodeString(parts[5]) + if err != nil || len(digest) != int(KeyLength) { + return nil, nil, ErrInvalidHash + } + + return salt, digest, nil +} diff --git a/internal/postgres/errors.go b/internal/postgres/errors.go new file mode 100644 index 0000000..f90becb --- /dev/null +++ b/internal/postgres/errors.go @@ -0,0 +1,10 @@ +package postgres + +import "errors" + +var ( + ErrConflict = errors.New("conflict") + ErrNotFound = errors.New("not found") + ErrInvalidMembers = errors.New("invalid members") + ErrInvalidCursor = errors.New("invalid cursor") +) diff --git a/internal/postgres/store.go b/internal/postgres/store.go new file mode 100644 index 0000000..949171d --- /dev/null +++ b/internal/postgres/store.go @@ -0,0 +1,469 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" +) + +type Store struct { + pool *pgxpool.Pool +} + +func New(pool *pgxpool.Pool) *Store { + return &Store{pool: pool} +} + +func (s *Store) Ping(ctx context.Context) error { + return s.pool.Ping(ctx) +} + +func (s *Store) CreateUser( + ctx context.Context, + username string, + displayName string, + passwordHash string, +) (model.User, error) { + const query = ` + INSERT INTO users (id, username, display_name, password_hash) + VALUES ($1, $2, $3, $4) + RETURNING id, username, display_name, created_at` + + var user model.User + err := s.pool.QueryRow(ctx, query, uuid.NewString(), username, displayName, passwordHash).Scan( + &user.ID, + &user.Username, + &user.DisplayName, + &user.CreatedAt, + ) + if isUniqueViolation(err) { + return model.User{}, ErrConflict + } + if err != nil { + return model.User{}, fmt.Errorf("create user: %w", err) + } + + return user, nil +} + +func (s *Store) UserByID(ctx context.Context, id string) (model.User, error) { + const query = ` + SELECT id, username, display_name, created_at + FROM users + WHERE id = $1` + + var user model.User + err := s.pool.QueryRow(ctx, query, id).Scan( + &user.ID, + &user.Username, + &user.DisplayName, + &user.CreatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.User{}, ErrNotFound + } + if err != nil { + return model.User{}, fmt.Errorf("get user by id: %w", err) + } + + return user, nil +} + +func (s *Store) UserByUsername(ctx context.Context, username string) (model.UserCredentials, error) { + const query = ` + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = $1` + + var credentials model.UserCredentials + err := s.pool.QueryRow(ctx, query, username).Scan( + &credentials.ID, + &credentials.Username, + &credentials.DisplayName, + &credentials.CreatedAt, + &credentials.PasswordHash, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.UserCredentials{}, ErrNotFound + } + if err != nil { + return model.UserCredentials{}, fmt.Errorf("get user by username: %w", err) + } + + return credentials, nil +} + +func (s *Store) CreateChat( + ctx context.Context, + title string, + memberIDs []string, + callerID string, +) (model.Chat, error) { + if !validMembers(memberIDs, callerID) { + return model.Chat{}, ErrInvalidMembers + } + + tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return model.Chat{}, fmt.Errorf("begin create chat transaction: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + valid, err := allUsersExist(ctx, tx, memberIDs) + if err != nil { + return model.Chat{}, err + } + if !valid { + return model.Chat{}, ErrInvalidMembers + } + + chat, err := insertChat(ctx, tx, title) + if err != nil { + return model.Chat{}, err + } + if err := insertMembers(ctx, tx, chat.ID, memberIDs); err != nil { + return model.Chat{}, err + } + if err := tx.Commit(ctx); err != nil { + return model.Chat{}, fmt.Errorf("commit create chat transaction: %w", err) + } + + chat.MemberIDs = append([]string(nil), memberIDs...) + return chat, nil +} + +func validMembers(memberIDs []string, callerID string) bool { + callerUUID, err := uuid.Parse(callerID) + if err != nil { + return false + } + + seen := make(map[uuid.UUID]struct{}, len(memberIDs)) + callerIncluded := false + for _, memberID := range memberIDs { + memberUUID, err := uuid.Parse(memberID) + if err != nil { + return false + } + if _, exists := seen[memberUUID]; exists { + return false + } + + seen[memberUUID] = struct{}{} + callerIncluded = callerIncluded || memberUUID == callerUUID + } + + return callerIncluded +} + +func allUsersExist(ctx context.Context, tx pgx.Tx, memberIDs []string) (bool, error) { + const query = ` + SELECT count(*) + FROM users + WHERE id::text = ANY($1)` + + var count int + if err := tx.QueryRow(ctx, query, memberIDs).Scan(&count); err != nil { + return false, fmt.Errorf("check chat members: %w", err) + } + + return count == len(memberIDs), nil +} + +func insertChat(ctx context.Context, tx pgx.Tx, title string) (model.Chat, error) { + const query = ` + INSERT INTO chats (id, title) + VALUES ($1, $2) + RETURNING id, title, created_at` + + var chat model.Chat + if err := tx.QueryRow(ctx, query, uuid.NewString(), title).Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil { + return model.Chat{}, fmt.Errorf("insert chat: %w", err) + } + + return chat, nil +} + +func insertMembers(ctx context.Context, tx pgx.Tx, chatID string, memberIDs []string) error { + const query = ` + INSERT INTO chat_members (chat_id, user_id, position) + VALUES ($1, $2, $3)` + + batch := &pgx.Batch{} + for position, memberID := range memberIDs { + batch.Queue(query, chatID, memberID, position) + } + + results := tx.SendBatch(ctx, batch) + defer func() { _ = results.Close() }() + for range memberIDs { + if _, err := results.Exec(); err != nil { + return fmt.Errorf("insert chat member: %w", err) + } + } + if err := results.Close(); err != nil { + return fmt.Errorf("close chat members batch: %w", err) + } + + return nil +} + +func (s *Store) ChatForUser(ctx context.Context, chatID, userID string) (model.Chat, error) { + const query = ` + SELECT c.id, c.title, c.created_at, + array_agg(cm.user_id::text ORDER BY cm.position) + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE c.id = $1 + AND EXISTS ( + SELECT 1 + FROM chat_members visible + WHERE visible.chat_id = c.id AND visible.user_id = $2 + ) + GROUP BY c.id, c.title, c.created_at` + + var chat model.Chat + err := s.pool.QueryRow(ctx, query, chatID, userID).Scan( + &chat.ID, + &chat.Title, + &chat.CreatedAt, + &chat.MemberIDs, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Chat{}, ErrNotFound + } + if err != nil { + return model.Chat{}, fmt.Errorf("get chat for user: %w", err) + } + + return chat, nil +} + +func (s *Store) ListChats( + ctx context.Context, + userID string, + after *model.Position, + limit int, +) ([]model.Chat, bool, error) { + if after != nil { + valid, err := s.visibleChatPositionExists(ctx, userID, *after) + if err != nil { + return nil, false, err + } + if !valid { + return nil, false, ErrInvalidCursor + } + } + + const query = ` + SELECT c.id, c.title, c.created_at, + array_agg(all_members.user_id::text ORDER BY all_members.position) + FROM chats c + JOIN chat_members visible ON visible.chat_id = c.id AND visible.user_id = $1 + JOIN chat_members all_members ON all_members.chat_id = c.id + WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3::uuid)) + GROUP BY c.id, c.title, c.created_at + ORDER BY c.created_at, c.id + LIMIT $4` + + var afterTime any + var afterID any + if after != nil { + afterTime = after.CreatedAt + afterID = after.ID + } + + rows, err := s.pool.Query(ctx, query, userID, afterTime, afterID, limit+1) + if err != nil { + return nil, false, fmt.Errorf("list chats: %w", err) + } + defer rows.Close() + + chats, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Chat](func(row pgx.CollectableRow) (model.Chat, error) { + var chat model.Chat + err := row.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs) + return chat, err + })) + if err != nil { + return nil, false, fmt.Errorf("scan chats: %w", err) + } + + return page(chats, limit) +} + +func (s *Store) visibleChatPositionExists( + ctx context.Context, + userID string, + position model.Position, +) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE cm.user_id = $1 AND c.created_at = $2 AND c.id = $3 + )` + + var exists bool + if err := s.pool.QueryRow(ctx, query, userID, position.CreatedAt, position.ID).Scan(&exists); err != nil { + return false, fmt.Errorf("validate chat cursor: %w", err) + } + + return exists, nil +} + +func (s *Store) CreateMessage( + ctx context.Context, + chatID string, + senderID string, + text string, +) (model.Message, error) { + const query = ` + INSERT INTO messages (id, chat_id, sender_id, text) + SELECT $1, $2, $3, $4 + WHERE EXISTS ( + SELECT 1 + FROM chat_members + WHERE chat_id = $2 AND user_id = $3 + ) + RETURNING id, chat_id, sender_id, text, created_at` + + var message model.Message + err := s.pool.QueryRow(ctx, query, uuid.NewString(), chatID, senderID, text).Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Message{}, ErrNotFound + } + if err != nil { + return model.Message{}, fmt.Errorf("create message: %w", err) + } + + return message, nil +} + +func (s *Store) ListMessages( + ctx context.Context, + chatID string, + userID string, + after *model.Position, + limit int, +) ([]model.Message, bool, error) { + visible, err := s.chatVisible(ctx, chatID, userID) + if err != nil { + return nil, false, err + } + if !visible { + return nil, false, ErrNotFound + } + if after != nil { + valid, err := s.messagePositionExists(ctx, chatID, *after) + if err != nil { + return nil, false, err + } + if !valid { + return nil, false, ErrInvalidCursor + } + } + + const query = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3::uuid)) + ORDER BY created_at, id + LIMIT $4` + + var afterTime any + var afterID any + if after != nil { + afterTime = after.CreatedAt + afterID = after.ID + } + + rows, err := s.pool.Query(ctx, query, chatID, afterTime, afterID, limit+1) + if err != nil { + return nil, false, fmt.Errorf("list messages: %w", err) + } + defer rows.Close() + + messages, err := pgx.CollectRows(rows, pgx.RowToFunc[model.Message](func(row pgx.CollectableRow) (model.Message, error) { + var message model.Message + err := row.Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + return message, err + })) + if err != nil { + return nil, false, fmt.Errorf("scan messages: %w", err) + } + + return page(messages, limit) +} + +func (s *Store) chatVisible(ctx context.Context, chatID, userID string) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM chat_members + WHERE chat_id = $1 AND user_id = $2 + )` + + var exists bool + if err := s.pool.QueryRow(ctx, query, chatID, userID).Scan(&exists); err != nil { + return false, fmt.Errorf("check chat visibility: %w", err) + } + + return exists, nil +} + +func (s *Store) messagePositionExists( + ctx context.Context, + chatID string, + position model.Position, +) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM messages + WHERE chat_id = $1 AND created_at = $2 AND id = $3 + )` + + var exists bool + if err := s.pool.QueryRow(ctx, query, chatID, position.CreatedAt, position.ID).Scan(&exists); err != nil { + return false, fmt.Errorf("validate message cursor: %w", err) + } + + return exists, nil +} + +func page[T any](items []T, limit int) ([]T, bool, error) { + if limit < 1 { + return nil, false, fmt.Errorf("limit must be positive") + } + if len(items) <= limit { + return items, false, nil + } + + return items[:limit], true, nil +} + +func isUniqueViolation(err error) bool { + var postgresError *pgconn.PgError + return errors.As(err, &postgresError) && postgresError.Code == "23505" +} diff --git a/internal/session/session.go b/internal/session/session.go new file mode 100644 index 0000000..4f40fc5 --- /dev/null +++ b/internal/session/session.go @@ -0,0 +1,161 @@ +package session + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "strings" + "time" + + "github.com/valkey-io/valkey-go" +) + +const ( + tokenLength = 32 + keyPrefix = "session:" +) + +var ( + ErrNotFound = errors.New("session not found") + ErrInvalidToken = errors.New("invalid session token") + ErrInvalidRecord = errors.New("invalid session record") + ErrInvalidTTL = errors.New("invalid session TTL") + ErrTokenGeneration = errors.New("session token generation failed") + ErrStore = errors.New("session store failure") +) + +type record struct { + UserID string `json:"user_id"` + ExpiresAt time.Time `json:"expires_at"` +} + +type Store struct { + client valkey.Client +} + +func New(rawURL string) (*Store, error) { + option, err := valkey.ParseURL(rawURL) + if err != nil { + return nil, fmt.Errorf("%w: parse Valkey URL: %w", ErrStore, err) + } + + client, err := valkey.NewClient(option) + if err != nil { + return nil, fmt.Errorf("%w: create Valkey client: %w", ErrStore, err) + } + + return &Store{client: client}, nil +} + +func (s *Store) Create(ctx context.Context, userID string, ttl time.Duration) (string, time.Time, error) { + if strings.TrimSpace(userID) == "" { + return "", time.Time{}, ErrInvalidRecord + } + if ttl < time.Second { + return "", time.Time{}, ErrInvalidTTL + } + + token, err := newToken() + if err != nil { + return "", time.Time{}, err + } + + record := record{ + UserID: userID, + ExpiresAt: time.Now().UTC().Add(ttl).Truncate(time.Microsecond), + } + payload, err := json.Marshal(record) + if err != nil { + return "", time.Time{}, fmt.Errorf("%w: encode session: %w", ErrStore, err) + } + + command := s.client.B().Set().Key(s.key(token)).Value(valkey.BinaryString(payload)).Ex(ttl).Build() + if err := s.client.Do(ctx, command).Error(); err != nil { + return "", time.Time{}, fmt.Errorf("%w: create session: %w", ErrStore, err) + } + + return token, record.ExpiresAt, nil +} + +func newToken() (string, error) { + random := make([]byte, tokenLength) + if _, err := rand.Read(random); err != nil { + return "", fmt.Errorf("%w: %v", ErrTokenGeneration, err) + } + return base64.RawURLEncoding.EncodeToString(random), nil +} + +func (s *Store) UserID(ctx context.Context, token string) (string, error) { + key, err := s.sessionKey(token) + if err != nil { + return "", err + } + + payload, err := s.client.Do(ctx, s.client.B().Get().Key(key).Build()).AsBytes() + if valkey.IsValkeyNil(err) { + return "", ErrNotFound + } + if err != nil { + return "", fmt.Errorf("%w: get session: %w", ErrStore, err) + } + + var record record + if err := json.Unmarshal(payload, &record); err != nil { + return "", fmt.Errorf("%w: decode session: %w", ErrStore, err) + } + if strings.TrimSpace(record.UserID) == "" || record.ExpiresAt.IsZero() { + return "", fmt.Errorf("%w: %w", ErrStore, ErrInvalidRecord) + } + if !record.ExpiresAt.After(time.Now()) { + return "", ErrNotFound + } + + return record.UserID, nil +} + +func (s *Store) Delete(ctx context.Context, token string) error { + key, err := s.sessionKey(token) + if err != nil { + return err + } + + deleted, err := s.client.Do(ctx, s.client.B().Del().Key(key).Build()).AsInt64() + if err != nil { + return fmt.Errorf("%w: delete session: %w", ErrStore, err) + } + if deleted == 0 { + return ErrNotFound + } + + return nil +} + +func (s *Store) Ping(ctx context.Context) error { + if err := s.client.Do(ctx, s.client.B().Ping().Build()).Error(); err != nil { + return fmt.Errorf("%w: ping Valkey: %w", ErrStore, err) + } + return nil +} + +func (s *Store) Close() error { + s.client.Close() + return nil +} + +func (s *Store) sessionKey(token string) (string, error) { + decoded, err := base64.RawURLEncoding.Strict().DecodeString(token) + if err != nil || len(decoded) != tokenLength { + return "", ErrInvalidToken + } + return s.key(token), nil +} + +func (s *Store) key(token string) string { + digest := sha256.Sum256([]byte(token)) + return keyPrefix + hex.EncodeToString(digest[:]) +} diff --git a/migrations/0001_initial.sql b/migrations/0001_initial.sql new file mode 100644 index 0000000..2f9b90b --- /dev/null +++ b/migrations/0001_initial.sql @@ -0,0 +1,50 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_length CHECK (char_length(display_name) BETWEEN 1 AND 100), + CONSTRAINT users_display_name_not_blank CHECK (display_name ~ '[^[:space:]]'), + CONSTRAINT users_password_hash_length CHECK (char_length(password_hash) BETWEEN 1 AND 1024), + CONSTRAINT users_password_hash_not_blank CHECK (password_hash ~ '[^[:space:]]') +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_length CHECK (char_length(title) BETWEEN 1 AND 100), + CONSTRAINT chats_title_not_blank CHECK (title ~ '[^[:space:]]') +); + +CREATE INDEX chats_created_at_id_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL, + user_id UUID NOT NULL, + position SMALLINT NOT NULL, + CONSTRAINT chat_members_pk PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_chat_position_unique UNIQUE (chat_id, position), + CONSTRAINT chat_members_position_range CHECK (position BETWEEN 0 AND 99), + CONSTRAINT chat_members_chat_fk FOREIGN KEY (chat_id) REFERENCES chats (id) ON DELETE CASCADE, + CONSTRAINT chat_members_user_fk FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE +); + +CREATE INDEX chat_members_user_id_chat_id_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL, + sender_id UUID NOT NULL, + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT messages_text_length CHECK (char_length(text) BETWEEN 1 AND 4000), + CONSTRAINT messages_text_not_blank CHECK (text ~ '[^[:space:]]'), + CONSTRAINT messages_sender_membership_fk FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id) ON DELETE CASCADE +); + +CREATE INDEX messages_chat_id_created_at_id_idx ON messages (chat_id, created_at, id); diff --git a/migrations/embed.go b/migrations/embed.go new file mode 100644 index 0000000..08bbf60 --- /dev/null +++ b/migrations/embed.go @@ -0,0 +1,8 @@ +package migrations + +import "embed" + +// FS contains database migrations applied by the application at startup. +// +//go:embed *.sql +var FS embed.FS -- 2.54.0 From 1f511728c9e2f0fd85aef4bd7d079b8cc6ee9e0d Mon Sep 17 00:00:00 2001 From: dizi Date: Thu, 24 Sep 2026 10:50:50 +0300 Subject: [PATCH 2/5] test: add resilience and benchmark verification --- cmd/dependencycheck/main.go | 165 +++++++++++++ cmd/lab2experiment/main.go | 236 +++++++++++++++++++ cmd/messenger/main_test.go | 28 +++ evidence/lab2-backup-restore.txt | 9 + evidence/lab2-track2.json | 234 ++++++++++++++++++ evidence/lab2-verification.txt | 14 ++ internal/messenger/server_test.go | 173 ++++++++++++++ internal/model/model_test.go | 18 ++ internal/password/password_test.go | 33 +++ internal/postgres/store_integration_test.go | 115 +++++++++ internal/session/session_integration_test.go | 83 +++++++ scripts/backup-restore.sh | 87 +++++++ scripts/restart.sh | 8 + 13 files changed, 1203 insertions(+) create mode 100644 cmd/dependencycheck/main.go create mode 100644 cmd/lab2experiment/main.go create mode 100644 cmd/messenger/main_test.go create mode 100644 evidence/lab2-backup-restore.txt create mode 100644 evidence/lab2-track2.json create mode 100644 evidence/lab2-verification.txt create mode 100644 internal/messenger/server_test.go create mode 100644 internal/model/model_test.go create mode 100644 internal/password/password_test.go create mode 100644 internal/postgres/store_integration_test.go create mode 100644 internal/session/session_integration_test.go create mode 100755 scripts/backup-restore.sh create mode 100755 scripts/restart.sh diff --git a/cmd/dependencycheck/main.go b/cmd/dependencycheck/main.go new file mode 100644 index 0000000..d22455f --- /dev/null +++ b/cmd/dependencycheck/main.go @@ -0,0 +1,165 @@ +package main + +import ( + "bytes" + "encoding/json" + "flag" + "fmt" + "io" + "net/http" + "os" + "os/exec" + "strings" + "time" + + "github.com/google/uuid" +) + +type apiClient struct { + baseURL string + client *http.Client + token string +} + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + fmt.Println("PASS: PostgreSQL and Valkey outage recovery") +} + +func run() error { + baseURL := flag.String("base-url", "http://localhost:8080", "API base URL") + flag.Parse() + client := &apiClient{baseURL: *baseURL, client: &http.Client{Timeout: 10 * time.Second}} + if err := client.registerAndLogin(); err != nil { + return err + } + if err := client.expect(http.MethodGet, "/api/v1/users/me", http.StatusOK, true); err != nil { + return err + } + if err := verifyOutage(client, "valkey"); err != nil { + return err + } + return verifyOutage(client, "postgres") +} + +func (c *apiClient) registerAndLogin() error { + username := "dep_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:16] + password := "T3st-" + uuid.NewString() + body := map[string]string{"username": username, "display_name": "Dependency check", "password": password} + payload, err := json.Marshal(body) + if err != nil { + return err + } + request, err := http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/users", bytes.NewReader(payload)) + if err != nil { + return err + } + request.Header.Set("Content-Type", "application/json") + response, err := c.client.Do(request) + if err != nil { + return fmt.Errorf("register: %w", err) + } + if err := closeResponse(response, http.StatusCreated); err != nil { + return fmt.Errorf("register: %w", err) + } + + request, err = http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/auth/sessions", nil) + if err != nil { + return err + } + request.SetBasicAuth(username, password) + response, err = c.client.Do(request) + if err != nil { + return fmt.Errorf("login: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + return fmt.Errorf("login status = %d", response.StatusCode) + } + var session struct { + Token string `json:"token"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&session); err != nil { + return fmt.Errorf("decode session: %w", err) + } + if session.Token == "" { + return fmt.Errorf("login returned an empty token") + } + c.token = session.Token + return nil +} + +func verifyOutage(client *apiClient, service string) (returnErr error) { + if err := compose("stop", service); err != nil { + return err + } + defer func() { + if err := compose("up", "-d", "--wait", "--wait-timeout", "90", service); returnErr == nil && err != nil { + returnErr = err + } + }() + if err := client.expectEventually("/health/ready", http.StatusServiceUnavailable, false); err != nil { + return fmt.Errorf("%s readiness outage: %w", service, err) + } + if err := client.expectEventually("/api/v1/users/me", http.StatusServiceUnavailable, true); err != nil { + return fmt.Errorf("%s business outage: %w", service, err) + } + if err := compose("up", "-d", "--wait", "--wait-timeout", "90", service); err != nil { + return err + } + if err := client.expectEventually("/health/ready", http.StatusOK, false); err != nil { + return fmt.Errorf("%s readiness recovery: %w", service, err) + } + if err := client.expectEventually("/api/v1/users/me", http.StatusOK, true); err != nil { + return fmt.Errorf("%s session recovery: %w", service, err) + } + return nil +} + +func compose(arguments ...string) error { + command := exec.Command("docker", append([]string{"compose"}, arguments...)...) + if output, err := command.CombinedOutput(); err != nil { + return fmt.Errorf("docker compose %v: %w: %s", arguments, err, bytes.TrimSpace(output)) + } + return nil +} + +func (c *apiClient) expectEventually(path string, status int, authenticated bool) error { + deadline := time.Now().Add(20 * time.Second) + var lastErr error + for time.Now().Before(deadline) { + lastErr = c.expect(http.MethodGet, path, status, authenticated) + if lastErr == nil { + return nil + } + time.Sleep(200 * time.Millisecond) + } + return lastErr +} + +func (c *apiClient) expect(method, path string, status int, authenticated bool) error { + request, err := http.NewRequest(method, c.baseURL+path, nil) + if err != nil { + return err + } + if authenticated { + request.Header.Set("Authorization", "Bearer "+c.token) + } + response, err := c.client.Do(request) + if err != nil { + return err + } + return closeResponse(response, status) +} + +func closeResponse(response *http.Response, status int) error { + defer func() { _ = response.Body.Close() }() + _, _ = io.Copy(io.Discard, io.LimitReader(response.Body, 1<<20)) + if response.StatusCode != status { + return fmt.Errorf("status = %d, want %d", response.StatusCode, status) + } + return nil +} diff --git a/cmd/lab2experiment/main.go b/cmd/lab2experiment/main.go new file mode 100644 index 0000000..ac4f781 --- /dev/null +++ b/cmd/lab2experiment/main.go @@ -0,0 +1,236 @@ +package main + +import ( + "context" + "encoding/json" + "flag" + "fmt" + "os" + "runtime" + "sort" + "strconv" + "strings" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +const experimentSchema = "lab2_experiment" + +type report struct { + GeneratedAt string `json:"generated_at"` + GoVersion string `json:"go_version"` + Platform string `json:"platform"` + CPUs int `json:"cpus"` + Messages int `json:"messages"` + Distribution []int `json:"chat_distribution"` + SeedDuration float64 `json:"seed_duration_seconds"` + Plans []planResult `json:"plans"` + Writes []writeResult `json:"writes"` +} + +type planResult struct { + Name string `json:"name"` + DDL string `json:"ddl"` + Plan json.RawMessage `json:"plan"` +} + +type writeResult struct { + Name string `json:"name"` + Rows int `json:"rows"` + SamplesSeconds []float64 `json:"samples_seconds"` + MedianSeconds float64 `json:"median_seconds"` + RowsPerSec float64 `json:"rows_per_second"` + IndexBytes int64 `json:"index_bytes"` +} + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +func run() error { + urlFile := flag.String("database-url-file", "secrets/database_url", "file containing the PostgreSQL URL") + output := flag.String("output", "evidence/lab2-track2.json", "result JSON path") + messages := flag.Int("messages", 100000, "number of messages") + writeRows := flag.Int("write-rows", 10000, "rows per write test") + flag.Parse() + if *messages < 100000 { + return fmt.Errorf("messages must be at least 100000") + } + if *writeRows < 1000 { + return fmt.Errorf("write-rows must be at least 1000") + } + + data, err := os.ReadFile(*urlFile) + if err != nil { + return fmt.Errorf("read database URL: %w", err) + } + pool, err := pgxpool.New(context.Background(), strings.TrimSpace(string(data))) + if err != nil { + return fmt.Errorf("open database: %w", err) + } + defer pool.Close() + + distribution := messageDistribution(*messages, 20) + seedStarted := time.Now() + chatIDs, err := seed(context.Background(), pool, distribution) + if err != nil { + return err + } + result := report{ + GeneratedAt: time.Now().UTC().Format(time.RFC3339), + GoVersion: runtime.Version(), Platform: runtime.GOOS + "/" + runtime.GOARCH, + CPUs: runtime.NumCPU(), Messages: *messages, Distribution: distribution, + SeedDuration: time.Since(seedStarted).Seconds(), + } + result.Plans, err = comparePlans(context.Background(), pool, chatIDs[len(chatIDs)-1], distribution[len(distribution)-1]) + if err != nil { + return err + } + result.Writes, err = compareWrites(context.Background(), pool, *writeRows) + if err != nil { + return err + } + payload, err := json.MarshalIndent(result, "", " ") + if err != nil { + return fmt.Errorf("encode report: %w", err) + } + if err := os.WriteFile(*output, append(payload, '\n'), 0o644); err != nil { + return fmt.Errorf("write report: %w", err) + } + return nil +} + +func messageDistribution(total, chats int) []int { + distribution := make([]int, chats) + distribution[0] = total * 60 / 100 + distribution[1] = total * 20 / 100 + distribution[2] = total * 10 / 100 + remaining := total - distribution[0] - distribution[1] - distribution[2] + for i := 3; i < chats; i++ { + distribution[i] = remaining / (chats - 3) + } + for assigned := sum(distribution); assigned < total; assigned++ { + distribution[chats-1]++ + } + return distribution +} + +func sum(values []int) int { + var result int + for _, value := range values { + result += value + } + return result +} + +func seed(ctx context.Context, pool *pgxpool.Pool, distribution []int) ([]uuid.UUID, error) { + if _, err := pool.Exec(ctx, `DROP SCHEMA IF EXISTS `+experimentSchema+` CASCADE; CREATE SCHEMA `+experimentSchema+`; CREATE TABLE `+experimentSchema+`.messages (id uuid PRIMARY KEY, chat_id uuid NOT NULL, created_at timestamptz NOT NULL, text text NOT NULL)`); err != nil { + return nil, fmt.Errorf("create experiment table: %w", err) + } + chatIDs := make([]uuid.UUID, len(distribution)) + for i := range chatIDs { + chatIDs[i] = uuid.NewSHA1(uuid.NameSpaceOID, []byte("chat-"+strconv.Itoa(i))) + } + base := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC) + rows := make([][]any, 0, sum(distribution)) + sequence := 0 + for chatIndex, count := range distribution { + for i := range count { + id := uuid.NewSHA1(chatIDs[chatIndex], []byte(strconv.Itoa(i))) + text := strings.Repeat("m", 32+(i%16)*32) + sequence = i*len(distribution) + chatIndex + rows = append(rows, []any{id, chatIDs[chatIndex], base.Add(time.Duration(sequence) * time.Microsecond), text}) + } + } + if _, err := pool.CopyFrom(ctx, pgx.Identifier{experimentSchema, "messages"}, []string{"id", "chat_id", "created_at", "text"}, pgx.CopyFromRows(rows)); err != nil { + return nil, fmt.Errorf("seed messages: %w", err) + } + return chatIDs, nil +} + +func comparePlans(ctx context.Context, pool *pgxpool.Pool, chatID uuid.UUID, count int) ([]planResult, error) { + base := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC) + middle := count / 2 + cursorTime := base.Add(time.Duration(middle*20+19) * time.Microsecond) + cursorID := uuid.NewSHA1(chatID, []byte(strconv.Itoa(middle))) + candidates := []struct { + name string + ddl string + }{ + {"history_composite", `CREATE INDEX experiment_history_idx ON ` + experimentSchema + `.messages (chat_id, created_at, id)`}, + {"global_time", `CREATE INDEX experiment_history_idx ON ` + experimentSchema + `.messages (created_at, id)`}, + } + results := make([]planResult, 0, len(candidates)) + for _, candidate := range candidates { + if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS `+experimentSchema+`.experiment_history_idx; `+candidate.ddl+`; ANALYZE `+experimentSchema+`.messages`); err != nil { + return nil, fmt.Errorf("prepare %s index: %w", candidate.name, err) + } + const explain = `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) +SELECT id, chat_id, created_at, text +FROM lab2_experiment.messages +WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +ORDER BY created_at, id +LIMIT 100` + var raw []byte + if err := pool.QueryRow(ctx, explain, chatID, cursorTime, cursorID).Scan(&raw); err != nil { + return nil, fmt.Errorf("explain %s: %w", candidate.name, err) + } + results = append(results, planResult{Name: candidate.name, DDL: candidate.ddl, Plan: json.RawMessage(raw)}) + } + return results, nil +} + +func compareWrites(ctx context.Context, pool *pgxpool.Pool, rows int) ([]writeResult, error) { + const repetitions = 5 + candidates := []struct { + name string + ddl string + }{ + {"no_secondary_index", ""}, + {"history_composite", `CREATE INDEX write_history_idx ON ` + experimentSchema + `.write_messages (chat_id, created_at, id)`}, + {"global_time", `CREATE INDEX write_history_idx ON ` + experimentSchema + `.write_messages (created_at, id)`}, + } + results := make([]writeResult, 0, len(candidates)) + for _, candidate := range candidates { + samples := make([]float64, 0, repetitions) + var indexBytes int64 + for repetition := range repetitions { + if _, err := pool.Exec(ctx, `DROP TABLE IF EXISTS `+experimentSchema+`.write_messages; CREATE TABLE `+experimentSchema+`.write_messages (id uuid PRIMARY KEY, chat_id uuid NOT NULL, created_at timestamptz NOT NULL, text text NOT NULL); `+candidate.ddl); err != nil { + return nil, fmt.Errorf("prepare write test %s: %w", candidate.name, err) + } + values := make([][]any, rows) + base := time.Date(2026, time.January, 1, 0, 0, repetition, 0, time.UTC) + for i := range rows { + values[i] = []any{ + uuid.NewSHA1(uuid.NameSpaceOID, []byte(strconv.Itoa(i))), + uuid.NewSHA1(uuid.NameSpaceURL, []byte(strconv.Itoa(i%20))), + base.Add(time.Duration(i) * time.Microsecond), + "message", + } + } + started := time.Now() + if _, err := pool.CopyFrom(ctx, pgx.Identifier{experimentSchema, "write_messages"}, []string{"id", "chat_id", "created_at", "text"}, pgx.CopyFromRows(values)); err != nil { + return nil, fmt.Errorf("write test %s: %w", candidate.name, err) + } + samples = append(samples, time.Since(started).Seconds()) + if candidate.ddl != "" { + if err := pool.QueryRow(ctx, `SELECT pg_relation_size($1::regclass)`, experimentSchema+".write_history_idx").Scan(&indexBytes); err != nil { + return nil, fmt.Errorf("read %s index size: %w", candidate.name, err) + } + } + } + sort.Float64s(samples) + median := samples[len(samples)/2] + results = append(results, writeResult{ + Name: candidate.name, Rows: rows, SamplesSeconds: samples, + MedianSeconds: median, RowsPerSec: float64(rows) / median, IndexBytes: indexBytes, + }) + } + return results, nil +} diff --git a/cmd/messenger/main_test.go b/cmd/messenger/main_test.go new file mode 100644 index 0000000..71ec372 --- /dev/null +++ b/cmd/messenger/main_test.go @@ -0,0 +1,28 @@ +package main + +import ( + "strings" + "testing" +) + +func TestRunRequiresAddress(t *testing.T) { + tests := []struct { + name string + host string + port string + want string + }{ + {name: "missing host", port: "8080", want: "APP_HOST is required"}, + {name: "missing port", host: "127.0.0.1", want: "APP_PORT is required"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Setenv("APP_HOST", tt.host) + t.Setenv("APP_PORT", tt.port) + if err := run(nil); err == nil || !strings.Contains(err.Error(), tt.want) { + t.Fatalf("run() error = %v, want %q", err, tt.want) + } + }) + } +} diff --git a/evidence/lab2-backup-restore.txt b/evidence/lab2-backup-restore.txt new file mode 100644 index 0000000..211ff96 --- /dev/null +++ b/evidence/lab2-backup-restore.txt @@ -0,0 +1,9 @@ +backup_format=PostgreSQL custom +restore_database=messenger_restore +users=35 +chats=9 +chat_members=17 +messages=8 +message_sample_digest_match=true +recovery_seconds=1 +rpo=backup snapshot; commits after pg_dump snapshot are outside the restore point diff --git a/evidence/lab2-track2.json b/evidence/lab2-track2.json new file mode 100644 index 0000000..1e47919 --- /dev/null +++ b/evidence/lab2-track2.json @@ -0,0 +1,234 @@ +{ + "generated_at": "2026-09-24T06:31:48Z", + "go_version": "go1.26.5", + "platform": "linux/arm64", + "cpus": 2, + "messages": 100000, + "chat_distribution": [ + 60000, + 20000, + 10000, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 588, + 592 + ], + "seed_duration_seconds": 0.297102214, + "plans": [ + { + "name": "history_composite", + "ddl": "CREATE INDEX experiment_history_idx ON lab2_experiment.messages (chat_id, created_at, id)", + "plan": [ + { + "Plan": { + "Node Type": "Limit", + "Parallel Aware": false, + "Async Capable": false, + "Startup Cost": 0.42, + "Total Cost": 271.86, + "Plan Rows": 100, + "Plan Width": 315, + "Actual Startup Time": 0.020, + "Actual Total Time": 0.042, + "Actual Rows": 100, + "Actual Loops": 1, + "Shared Hit Blocks": 6, + "Shared Read Blocks": 4, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Plans": [ + { + "Node Type": "Index Scan", + "Parent Relationship": "Outer", + "Parallel Aware": false, + "Async Capable": false, + "Scan Direction": "Forward", + "Index Name": "experiment_history_idx", + "Relation Name": "messages", + "Alias": "messages", + "Startup Cost": 0.42, + "Total Cost": 1411.91, + "Plan Rows": 520, + "Plan Width": 315, + "Actual Startup Time": 0.019, + "Actual Total Time": 0.037, + "Actual Rows": 100, + "Actual Loops": 1, + "Index Cond": "((chat_id = '62ec06f6-c3c9-5e9b-a213-28604e4f69cd'::uuid) AND (ROW(created_at, id) \u003e ROW('2026-01-01 00:00:00.005939+00'::timestamp with time zone, 'd160edac-1f4b-57f8-a01f-cbbfd7250741'::uuid)))", + "Rows Removed by Index Recheck": 0, + "Shared Hit Blocks": 6, + "Shared Read Blocks": 4, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + } + ] + }, + "Planning": { + "Shared Hit Blocks": 51, + "Shared Read Blocks": 1, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.222, + "Triggers": [], + "Execution Time": 0.069 + } + ] + }, + { + "name": "global_time", + "ddl": "CREATE INDEX experiment_history_idx ON lab2_experiment.messages (created_at, id)", + "plan": [ + { + "Plan": { + "Node Type": "Limit", + "Parallel Aware": false, + "Async Capable": false, + "Startup Cost": 0.42, + "Total Cost": 3533.04, + "Plan Rows": 100, + "Plan Width": 315, + "Actual Startup Time": 0.055, + "Actual Total Time": 0.584, + "Actual Rows": 100, + "Actual Loops": 1, + "Shared Hit Blocks": 1994, + "Shared Read Blocks": 19, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Plans": [ + { + "Node Type": "Index Scan", + "Parent Relationship": "Outer", + "Parallel Aware": false, + "Async Capable": false, + "Scan Direction": "Forward", + "Index Name": "experiment_history_idx", + "Relation Name": "messages", + "Alias": "messages", + "Startup Cost": 0.42, + "Total Cost": 20524.95, + "Plan Rows": 581, + "Plan Width": 315, + "Actual Startup Time": 0.054, + "Actual Total Time": 0.578, + "Actual Rows": 100, + "Actual Loops": 1, + "Index Cond": "(ROW(created_at, id) \u003e ROW('2026-01-01 00:00:00.005939+00'::timestamp with time zone, 'd160edac-1f4b-57f8-a01f-cbbfd7250741'::uuid))", + "Rows Removed by Index Recheck": 0, + "Filter": "(chat_id = '62ec06f6-c3c9-5e9b-a213-28604e4f69cd'::uuid)", + "Rows Removed by Filter": 1900, + "Shared Hit Blocks": 1994, + "Shared Read Blocks": 19, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + } + ] + }, + "Planning": { + "Shared Hit Blocks": 33, + "Shared Read Blocks": 1, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.161, + "Triggers": [], + "Execution Time": 0.597 + } + ] + } + ], + "writes": [ + { + "name": "no_secondary_index", + "rows": 10000, + "samples_seconds": [ + 0.029270334, + 0.031755962, + 0.032344456, + 0.032778799, + 0.033289467 + ], + "median_seconds": 0.032344456, + "rows_per_second": 309171.9953490638, + "index_bytes": 0 + }, + { + "name": "history_composite", + "rows": 10000, + "samples_seconds": [ + 0.032376473, + 0.032606465, + 0.03496374, + 0.039391471, + 0.05066359 + ], + "median_seconds": 0.03496374, + "rows_per_second": 286010.5926883108, + "index_bytes": 991232 + }, + { + "name": "global_time", + "rows": 10000, + "samples_seconds": [ + 0.030691535, + 0.032534157, + 0.035047577, + 0.035801915, + 0.043506137 + ], + "median_seconds": 0.035047577, + "rows_per_second": 285326.4292707025, + "index_bytes": 425984 + } + ] +} diff --git a/evidence/lab2-verification.txt b/evidence/lab2-verification.txt new file mode 100644 index 0000000..2048419 --- /dev/null +++ b/evidence/lab2-verification.txt @@ -0,0 +1,14 @@ +date=2026-09-24 +environment=linux/arm64 containers, API limit 2 CPU and 512 MiB +make_check=PASS +openapi_validation=PASS +golangci_lint_2.13.2=0 issues +go_test_race_all=PASS +go_vet_all=PASS +go_build_messenger=PASS +compose_config=PASS +public_smoke=PASS: lab2 public API scenario +postgres_valkey_integration=PASS +dependency_outage=PASS: PostgreSQL and Valkey outage recovery +persistence=PASS: confirmed data and existing session preserved +migrations=PASS: repeated API restarts reused schema migration checksum without duplicate data diff --git a/internal/messenger/server_test.go b/internal/messenger/server_test.go new file mode 100644 index 0000000..641a779 --- /dev/null +++ b/internal/messenger/server_test.go @@ -0,0 +1,173 @@ +package messenger + +import ( + "context" + "errors" + "io" + "log/slog" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" +) + +var errDependency = errors.New("dependency unavailable") + +type repositoryStub struct { + pingErr error + userByID model.User + userByIDErr error + credentials model.UserCredentials + credentialsErr error +} + +func (s repositoryStub) Ping(context.Context) error { return s.pingErr } +func (repositoryStub) CreateUser(context.Context, string, string, string) (model.User, error) { + return model.User{}, nil +} +func (s repositoryStub) UserByID(context.Context, string) (model.User, error) { + return s.userByID, s.userByIDErr +} +func (s repositoryStub) UserByUsername(context.Context, string) (model.UserCredentials, error) { + return s.credentials, s.credentialsErr +} +func (repositoryStub) CreateChat(context.Context, string, []string, string) (model.Chat, error) { + return model.Chat{}, nil +} +func (repositoryStub) ChatForUser(context.Context, string, string) (model.Chat, error) { + return model.Chat{}, nil +} +func (repositoryStub) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) { + return nil, false, nil +} +func (repositoryStub) CreateMessage(context.Context, string, string, string) (model.Message, error) { + return model.Message{}, nil +} +func (repositoryStub) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) { + return nil, false, nil +} + +type sessionStub struct { + pingErr error + userID string + userIDErr error +} + +func (s sessionStub) Ping(context.Context) error { return s.pingErr } +func (sessionStub) Create(context.Context, string, time.Duration) (string, time.Time, error) { + return "token", time.Now().Add(time.Hour), nil +} +func (s sessionStub) UserID(context.Context, string) (string, error) { return s.userID, s.userIDErr } +func (sessionStub) Delete(context.Context, string) error { return nil } + +type passwordsStub struct { + verified bool + err error +} + +func (passwordsStub) Hash(string) (string, error) { return "hash", nil } +func (passwordsStub) DummyHash() string { return "hash" } +func (s passwordsStub) Verify(string, string) (bool, error) { + return s.verified, s.err +} + +func TestReadinessReturnsUnavailableForDependencyFailure(t *testing.T) { + tests := []struct { + name string + repo repositoryStub + sessions sessionStub + }{ + {name: "postgres", repo: repositoryStub{pingErr: errDependency}}, + {name: "valkey", sessions: sessionStub{pingErr: errDependency}}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + server := newTestServer(tt.repo, tt.sessions, passwordsStub{}) + response := serveRequest(server, http.MethodGet, "/health/ready", "") + if response.Code != http.StatusServiceUnavailable { + t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) + } + }) + } +} + +func TestBusinessRequestReturnsUnavailableForDependencyFailure(t *testing.T) { + tests := []struct { + name string + repo repositoryStub + sessions sessionStub + }{ + {name: "valkey", sessions: sessionStub{userIDErr: errDependency}}, + {name: "postgres", repo: repositoryStub{userByIDErr: errDependency}, sessions: sessionStub{userID: "user-id"}}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + server := newTestServer(tt.repo, tt.sessions, passwordsStub{}) + request := httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil) + request.Header.Set("Authorization", "Bearer valid-token") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusServiceUnavailable { + t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) + } + }) + } +} + +func TestAuthenticationChallenges(t *testing.T) { + server := newTestServer(repositoryStub{}, sessionStub{}, passwordsStub{}) + bearer := serveRequest(server, http.MethodGet, "/api/v1/users/me", "") + if bearer.Code != http.StatusUnauthorized || bearer.Header().Get("WWW-Authenticate") != `Bearer realm="messenger"` { + t.Fatalf("business challenge = %d %q", bearer.Code, bearer.Header().Get("WWW-Authenticate")) + } + + repository := repositoryStub{credentials: model.UserCredentials{PasswordHash: "hash"}} + server = newTestServer(repository, sessionStub{}, passwordsStub{verified: false}) + request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", nil) + request.SetBasicAuth("user", "wrong-password") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusUnauthorized || response.Header().Get("WWW-Authenticate") != `Basic realm="messenger", charset="UTF-8"` { + t.Fatalf("session challenge = %d %q", response.Code, response.Header().Get("WWW-Authenticate")) + } +} + +func TestSessionCreationRejectsChunkedBody(t *testing.T) { + server := newTestServer(repositoryStub{}, sessionStub{}, passwordsStub{}) + request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", strings.NewReader("{}")) + request.ContentLength = -1 + request.SetBasicAuth("user", "password") + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + if response.Code != http.StatusBadRequest { + t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) + } +} + +func TestRegistrationRejectsWhitespacePassword(t *testing.T) { + server := newTestServer(repositoryStub{}, sessionStub{}, passwordsStub{}) + response := serveRequest(server, http.MethodPost, "/api/v1/users", `{"username":"student","display_name":"Student","password":" "}`) + if response.Code != http.StatusBadRequest { + t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) + } +} + +func newTestServer(repository Repository, sessions SessionStore, passwords Passwords) *Server { + logger := slog.New(slog.NewTextHandler(io.Discard, nil)) + return NewServer(logger, repository, sessions, passwords, time.Hour, time.Second, "8081") +} + +func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { + request := httptest.NewRequest(method, path, strings.NewReader(body)) + if body != "" { + request.Header.Set("Content-Type", "application/json") + } + response := httptest.NewRecorder() + server.Handler().ServeHTTP(response, request) + return response +} diff --git a/internal/model/model_test.go b/internal/model/model_test.go new file mode 100644 index 0000000..7c0f2e4 --- /dev/null +++ b/internal/model/model_test.go @@ -0,0 +1,18 @@ +package model + +import ( + "encoding/json" + "testing" + "time" +) + +func TestUserTimestampHasFixedMicroseconds(t *testing.T) { + createdAt := time.Date(2026, time.September, 23, 21, 28, 15, 423030000, time.UTC) + data, err := json.Marshal(User{ID: "id", Username: "user", DisplayName: "User", CreatedAt: createdAt}) + if err != nil { + t.Fatalf("Marshal() error = %v", err) + } + if string(data) != `{"id":"id","username":"user","display_name":"User","created_at":"2026-09-23T21:28:15.423030Z"}` { + t.Fatalf("Marshal() = %s", data) + } +} diff --git a/internal/password/password_test.go b/internal/password/password_test.go new file mode 100644 index 0000000..f52aa08 --- /dev/null +++ b/internal/password/password_test.go @@ -0,0 +1,33 @@ +package password + +import "testing" + +func TestHasher(t *testing.T) { + hasher := Hasher{} + hash, err := hasher.Hash("T3st-password-123") + if err != nil { + t.Fatalf("Hash() error = %v", err) + } + + verified, err := hasher.Verify("T3st-password-123", hash) + if err != nil { + t.Fatalf("Verify() error = %v", err) + } + if !verified { + t.Fatal("Verify() = false for the original password") + } + + verified, err = hasher.Verify("wrong-password", hash) + if err != nil { + t.Fatalf("Verify() error = %v", err) + } + if verified { + t.Fatal("Verify() = true for a different password") + } +} + +func TestVerifyRejectsMalformedHash(t *testing.T) { + if _, err := (Hasher{}).Verify("password", "invalid"); err == nil { + t.Fatal("Verify() error = nil for malformed hash") + } +} diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go new file mode 100644 index 0000000..cc1112e --- /dev/null +++ b/internal/postgres/store_integration_test.go @@ -0,0 +1,115 @@ +package postgres_test + +import ( + "context" + "errors" + "os" + "strings" + "sync" + "testing" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgxpool" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" +) + +func TestConcurrentUsernameCreation(t *testing.T) { + pool := openTestDatabase(t) + store := postgres.New(pool) + username := "race_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:16] + + const workers = 8 + results := make(chan error, workers) + var group sync.WaitGroup + for range workers { + group.Add(1) + go func() { + defer group.Done() + _, err := store.CreateUser(context.Background(), username, "Race user", "password-hash") + results <- err + }() + } + group.Wait() + close(results) + + var created, conflicts int + for err := range results { + switch { + case err == nil: + created++ + case errors.Is(err, postgres.ErrConflict): + conflicts++ + default: + t.Fatalf("CreateUser() error = %v", err) + } + } + if created != 1 || conflicts != workers-1 { + t.Fatalf("created = %d, conflicts = %d", created, conflicts) + } +} + +func TestCreateChatRollsBackForUnknownMember(t *testing.T) { + pool := openTestDatabase(t) + store := postgres.New(pool) + owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash") + if err != nil { + t.Fatalf("CreateUser() error = %v", err) + } + + before := chatCount(t, pool) + _, err = store.CreateChat(context.Background(), "Invalid chat", []string{owner.ID, uuid.NewString()}, owner.ID) + if !errors.Is(err, postgres.ErrInvalidMembers) { + t.Fatalf("CreateChat() error = %v, want ErrInvalidMembers", err) + } + if after := chatCount(t, pool); after != before { + t.Fatalf("chat count changed from %d to %d", before, after) + } +} + +func openTestDatabase(t *testing.T) *pgxpool.Pool { + t.Helper() + url := testSecret(t, "TEST_DATABASE_URL", "TEST_DATABASE_URL_FILE") + pool, err := database.Open(context.Background(), database.Config{ + URL: url, MinConnections: 0, MaxConnections: 10, + MaxConnectionAge: time.Minute, MaxConnectionIdle: time.Minute, + HealthCheckPeriod: time.Minute, ConnectTimeout: 5 * time.Second, + MigrationTimeout: 30 * time.Second, + }) + if err != nil { + t.Fatalf("database.Open() error = %v", err) + } + t.Cleanup(pool.Close) + return pool +} + +func testSecret(t *testing.T, valueName, fileName string) string { + t.Helper() + if value := strings.TrimSpace(os.Getenv(valueName)); value != "" { + return value + } + path := strings.TrimSpace(os.Getenv(fileName)) + if path == "" { + t.Skipf("set %s or %s to run integration tests", valueName, fileName) + } + data, err := os.ReadFile(path) + if err != nil { + t.Fatalf("read %s: %v", fileName, err) + } + return strings.TrimSpace(string(data)) +} + +func uniqueUsername() string { + return "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:20] +} + +func chatCount(t *testing.T, pool *pgxpool.Pool) int { + t.Helper() + var count int + if err := pool.QueryRow(context.Background(), "SELECT count(*) FROM chats").Scan(&count); err != nil { + t.Fatalf("count chats: %v", err) + } + return count +} diff --git a/internal/session/session_integration_test.go b/internal/session/session_integration_test.go new file mode 100644 index 0000000..8a19a4b --- /dev/null +++ b/internal/session/session_integration_test.go @@ -0,0 +1,83 @@ +package session_test + +import ( + "context" + "errors" + "os" + "strings" + "testing" + "time" + + "github.com/google/uuid" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" +) + +func TestSessionLifecycle(t *testing.T) { + store := openTestStore(t) + userID := uuid.NewString() + token, expiresAt, err := store.Create(context.Background(), userID, time.Minute) + if err != nil { + t.Fatalf("Create() error = %v", err) + } + if token == "" || !expiresAt.After(time.Now()) { + t.Fatalf("invalid token or expiry: token length = %d, expires_at = %v", len(token), expiresAt) + } + + actualUserID, err := store.UserID(context.Background(), token) + if err != nil { + t.Fatalf("UserID() error = %v", err) + } + if actualUserID != userID { + t.Fatalf("UserID() = %q, want %q", actualUserID, userID) + } + if err := store.Delete(context.Background(), token); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if _, err := store.UserID(context.Background(), token); !errors.Is(err, session.ErrNotFound) { + t.Fatalf("UserID() after delete error = %v, want ErrNotFound", err) + } +} + +func TestSessionExpires(t *testing.T) { + store := openTestStore(t) + token, _, err := store.Create(context.Background(), uuid.NewString(), time.Second) + if err != nil { + t.Fatalf("Create() error = %v", err) + } + + deadline := time.Now().Add(3 * time.Second) + for time.Now().Before(deadline) { + _, err := store.UserID(context.Background(), token) + if errors.Is(err, session.ErrNotFound) { + return + } + if err != nil { + t.Fatalf("UserID() error = %v", err) + } + time.Sleep(50 * time.Millisecond) + } + t.Fatal("session did not expire within three seconds") +} + +func openTestStore(t *testing.T) *session.Store { + t.Helper() + url := strings.TrimSpace(os.Getenv("TEST_CACHE_URL")) + if url == "" { + path := strings.TrimSpace(os.Getenv("TEST_CACHE_URL_FILE")) + if path == "" { + t.Skip("set TEST_CACHE_URL or TEST_CACHE_URL_FILE to run integration tests") + } + data, err := os.ReadFile(path) + if err != nil { + t.Fatalf("read TEST_CACHE_URL_FILE: %v", err) + } + url = strings.TrimSpace(string(data)) + } + store, err := session.New(url) + if err != nil { + t.Fatalf("session.New() error = %v", err) + } + t.Cleanup(func() { _ = store.Close() }) + return store +} diff --git a/scripts/backup-restore.sh b/scripts/backup-restore.sh new file mode 100755 index 0000000..a15e8ba --- /dev/null +++ b/scripts/backup-restore.sh @@ -0,0 +1,87 @@ +#!/bin/sh + +set -eu + +restore_database=${RESTORE_DATABASE:-messenger_restore} +backup_file=$(mktemp) +trap 'rm -f "$backup_file"' EXIT + +started_at=$(date +%s) +docker compose exec -T postgres sh -eu -c ' + export PGPASSWORD="$(cat /run/secrets/postgres_password)" + pg_dump --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" --format custom +' > "$backup_file" + +docker compose exec -T postgres sh -eu -c ' + export PGPASSWORD="$(cat /run/secrets/postgres_password)" + dropdb --username "$POSTGRES_USER" --if-exists "$1" + createdb --username "$POSTGRES_USER" "$1" +' sh "$restore_database" + +docker compose exec -T postgres sh -eu -c ' + export PGPASSWORD="$(cat /run/secrets/postgres_password)" + pg_restore --username "$POSTGRES_USER" --dbname "$1" --no-owner --no-privileges +' sh "$restore_database" < "$backup_file" + +original=$(docker compose exec -T postgres sh -eu -c ' + export PGPASSWORD="$(cat /run/secrets/postgres_password)" + psql --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" --tuples-only --no-align --command " + SELECT count(*) FROM users; + SELECT count(*) FROM chats; + SELECT count(*) FROM chat_members; + SELECT count(*) FROM messages; + WITH sample AS ( + (SELECT * FROM messages ORDER BY created_at, id LIMIT 5) + UNION ALL + (SELECT * FROM messages ORDER BY created_at DESC, id DESC LIMIT 5) + ) + SELECT md5(COALESCE(string_agg( + id::text || '\''|'\'' || chat_id::text || '\''|'\'' || sender_id::text || '\''|'\'' || md5(text) || '\''|'\'' || created_at::text, + '\'';'\'' ORDER BY created_at, id + ), '\'''\'')) FROM sample; + " +') + +restored=$(docker compose exec -T postgres sh -eu -c ' + export PGPASSWORD="$(cat /run/secrets/postgres_password)" + psql --username "$POSTGRES_USER" --dbname "$1" --tuples-only --no-align --command " + SELECT count(*) FROM users; + SELECT count(*) FROM chats; + SELECT count(*) FROM chat_members; + SELECT count(*) FROM messages; + WITH sample AS ( + (SELECT * FROM messages ORDER BY created_at, id LIMIT 5) + UNION ALL + (SELECT * FROM messages ORDER BY created_at DESC, id DESC LIMIT 5) + ) + SELECT md5(COALESCE(string_agg( + id::text || '\''|'\'' || chat_id::text || '\''|'\'' || sender_id::text || '\''|'\'' || md5(text) || '\''|'\'' || created_at::text, + '\'';'\'' ORDER BY created_at, id + ), '\'''\'')) FROM sample; + " +' sh "$restore_database") + +if [ "$original" != "$restored" ]; then + echo "backup verification failed" >&2 + exit 1 +fi + +finished_at=$(date +%s) +users=$(printf '%s\n' "$original" | sed -n '1p') +chats=$(printf '%s\n' "$original" | sed -n '2p') +members=$(printf '%s\n' "$original" | sed -n '3p') +messages=$(printf '%s\n' "$original" | sed -n '4p') + +cat > evidence/lab2-backup-restore.txt < Date: Thu, 24 Sep 2026 10:51:02 +0300 Subject: [PATCH 3/5] ops: add containers and monitoring --- .dockerignore | 1 + .gitignore | 1 + Dockerfile | 24 +++ compose.yaml | 192 ++++++++++++++++++ lab2.env.example | 18 ++ monitoring/grafana/dashboards/messenger.json | 76 +++++++ .../provisioning/dashboards/messenger.yml | 10 + .../provisioning/datasources/prometheus.yml | 10 + monitoring/prometheus.yml | 16 ++ scripts/init-local-secrets.sh | 21 ++ 10 files changed, 369 insertions(+) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 lab2.env.example create mode 100644 monitoring/grafana/dashboards/messenger.json create mode 100644 monitoring/grafana/provisioning/dashboards/messenger.yml create mode 100644 monitoring/grafana/provisioning/datasources/prometheus.yml create mode 100644 monitoring/prometheus.yml create mode 100755 scripts/init-local-secrets.sh diff --git a/.dockerignore b/.dockerignore index bc16e55..ddd2c73 100644 --- a/.dockerignore +++ b/.dockerignore @@ -17,4 +17,5 @@ backups __pycache__ node_modules evidence +/messenger .DS_Store diff --git a/.gitignore b/.gitignore index b5a7189..37e0ed3 100644 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,7 @@ dist/ build/ target/ bin/ +/messenger obj/ coverage/ *.log diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..166dd09 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,24 @@ +FROM golang:1.26.5-alpine3.24 AS build + +WORKDIR /src +COPY . . +RUN go build ./cmd/messenger + +FROM build AS test + +CMD ["go", "test", "./internal/postgres", "./internal/session"] + +FROM build AS experiment + +CMD ["go", "run", "./cmd/lab2experiment"] + +FROM alpine:3.24.2 + +RUN addgroup -S app && adduser -S -G app -u 10001 app +COPY --from=build --chown=app:app /src/messenger /app/messenger + +USER app +WORKDIR /app +HEALTHCHECK --interval=10s --timeout=2s --start-period=5s --retries=3 \ + CMD wget -q -O /dev/null "http://127.0.0.1:${APP_PORT}/health/ready" || exit 1 +CMD ["/app/messenger"] diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..ea9a8dd --- /dev/null +++ b/compose.yaml @@ -0,0 +1,192 @@ +services: + postgres: + image: postgres:17.6-alpine3.22 + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_DB: ${POSTGRES_DB} + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 20 + cpus: ${POSTGRES_CPUS} + mem_limit: ${POSTGRES_MEMORY} + restart: unless-stopped + + valkey: + image: valkey/valkey:8.1.4-alpine + command: + - sh + - -c + - exec valkey-server --appendonly yes --appendfsync everysec --requirepass "$$(cat /run/secrets/valkey_password)" + secrets: + - valkey_password + volumes: + - valkey_data:/data + healthcheck: + test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(cat /run/secrets/valkey_password)\" ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 20 + cpus: ${VALKEY_CPUS} + mem_limit: ${VALKEY_MEMORY} + restart: unless-stopped + + api: + build: . + image: ${API_IMAGE:-mtusi-messenger:lab2} + env_file: .env + environment: + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: + - database_url + - cache_url + ports: + - "127.0.0.1:8080:${APP_PORT}" + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + cpus: ${API_CPUS} + mem_limit: ${API_MEMORY} + stop_grace_period: 10s + restart: unless-stopped + + swagger: + image: swaggerapi/swagger-ui:v5.31.2 + environment: + SWAGGER_JSON: /spec/openapi.json + volumes: + - ./contracts/openapi.json:/spec/openapi.json:ro + ports: + - "127.0.0.1:${SWAGGER_PORT}:8080" + depends_on: + api: + condition: service_healthy + restart: unless-stopped + + tests: + profiles: ["tests"] + build: + context: . + target: test + environment: + TEST_DATABASE_URL_FILE: /run/secrets/database_url + TEST_CACHE_URL_FILE: /run/secrets/cache_url + secrets: + - database_url + - cache_url + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + + experiment: + profiles: ["research"] + build: + context: . + target: experiment + command: + - go + - run + - ./cmd/lab2experiment + - -database-url-file=/run/secrets/database_url + - -output=/output/lab2-track2.json + secrets: + - database_url + volumes: + - ./evidence:/output + depends_on: + postgres: + condition: service_healthy + + postgres-exporter: + profiles: ["monitoring"] + image: quay.io/prometheuscommunity/postgres-exporter:v0.20.1 + environment: + DATA_SOURCE_URI: postgres:5432/${POSTGRES_DB}?sslmode=disable + DATA_SOURCE_USER: ${POSTGRES_USER} + DATA_SOURCE_PASS_FILE: /run/secrets/postgres_password + PG_EXPORTER_COLLECTION_TIMEOUT: 5s + secrets: + - postgres_password + depends_on: + postgres: + condition: service_healthy + restart: unless-stopped + + valkey-exporter: + profiles: ["monitoring"] + image: oliver006/redis_exporter:v1.89.0-alpine + entrypoint: ["/bin/sh", "-c"] + command: + - export REDIS_PASSWORD="$$(cat /run/secrets/valkey_password)"; exec /redis_exporter --redis.addr=redis://valkey:6379 --redis.user=default --connection-timeout=5s + secrets: + - valkey_password + depends_on: + valkey: + condition: service_healthy + restart: unless-stopped + + prometheus: + profiles: ["monitoring"] + image: prom/prometheus:v3.13.3 + command: + - --config.file=/etc/prometheus/prometheus.yml + - --storage.tsdb.path=/prometheus + - --storage.tsdb.retention.time=7d + volumes: + - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro + - prometheus_data:/prometheus + ports: + - "127.0.0.1:${PROMETHEUS_PORT}:9090" + depends_on: + - api + - postgres-exporter + - valkey-exporter + restart: unless-stopped + + grafana: + profiles: ["monitoring"] + image: grafana/grafana:13.1.6 + environment: + GF_SECURITY_ADMIN_USER: admin + GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password + GF_USERS_ALLOW_SIGN_UP: "false" + secrets: + - grafana_admin_password + volumes: + - ./monitoring/grafana/provisioning:/etc/grafana/provisioning:ro + - ./monitoring/grafana/dashboards:/var/lib/grafana/dashboards:ro + - grafana_data:/var/lib/grafana + ports: + - "127.0.0.1:${GRAFANA_PORT}:3000" + depends_on: + - prometheus + restart: unless-stopped + +secrets: + postgres_password: + file: ./secrets/postgres_password + valkey_password: + file: ./secrets/valkey_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + grafana_admin_password: + file: ./secrets/grafana_admin_password + +volumes: + postgres_data: + valkey_data: + prometheus_data: + grafana_data: diff --git a/lab2.env.example b/lab2.env.example new file mode 100644 index 0000000..7576a38 --- /dev/null +++ b/lab2.env.example @@ -0,0 +1,18 @@ +APP_HOST=0.0.0.0 +APP_PORT=8080 +SESSION_TTL_SECONDS=3600 +SESSION_STORE=valkey +DB_MIN_CONNS=1 +DB_MAX_CONNS=10 +DEPENDENCY_TIMEOUT_SECONDS=5 +SWAGGER_PORT=8081 +POSTGRES_USER=messenger +POSTGRES_DB=messenger +API_CPUS=2 +API_MEMORY=512m +POSTGRES_CPUS=2 +POSTGRES_MEMORY=1g +VALKEY_CPUS=1 +VALKEY_MEMORY=256m +PROMETHEUS_PORT=9090 +GRAFANA_PORT=3000 diff --git a/monitoring/grafana/dashboards/messenger.json b/monitoring/grafana/dashboards/messenger.json new file mode 100644 index 0000000..d724608 --- /dev/null +++ b/monitoring/grafana/dashboards/messenger.json @@ -0,0 +1,76 @@ +{ + "annotations": {"list": []}, + "editable": false, + "graphTooltip": 1, + "panels": [ + { + "type": "timeseries", "title": "API requests per second", "id": 1, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 0}, + "targets": [{"expr": "sum(rate(messenger_http_requests_total[1m]))", "legendFormat": "RPS", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API responses by status class", "id": 2, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 0}, + "targets": [{"expr": "sum by (status_class) (rate(messenger_http_requests_total[1m]))", "legendFormat": "{{status_class}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API latency p95", "id": 3, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 8}, + "fieldConfig": {"defaults": {"unit": "s"}, "overrides": []}, + "targets": [{"expr": "histogram_quantile(0.95, sum by (le, route) (rate(messenger_http_request_duration_seconds_bucket[5m])))", "legendFormat": "{{route}}", "refId": "A"}] + }, + { + "type": "timeseries", "title": "API in flight", "id": 4, + "gridPos": {"h": 8, "w": 6, "x": 12, "y": 8}, + "targets": [{"expr": "messenger_http_requests_in_flight", "legendFormat": "requests", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Go heap", "id": 5, + "gridPos": {"h": 8, "w": 6, "x": 18, "y": 8}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [{"expr": "go_memstats_heap_alloc_bytes{job=\"messenger\"}", "legendFormat": "heap", "refId": "A"}] + }, + { + "type": "timeseries", "title": "PostgreSQL connections", "id": 6, + "gridPos": {"h": 8, "w": 8, "x": 0, "y": 16}, + "targets": [{"expr": "sum(pg_stat_activity_count{datname=\"messenger\"})", "legendFormat": "connections", "refId": "A"}] + }, + { + "type": "timeseries", "title": "PostgreSQL transactions", "id": 7, + "gridPos": {"h": 8, "w": 8, "x": 8, "y": 16}, + "targets": [ + {"expr": "rate(pg_stat_database_xact_commit{datname=\"messenger\"}[1m])", "legendFormat": "commit/s", "refId": "A"}, + {"expr": "rate(pg_stat_database_xact_rollback{datname=\"messenger\"}[1m])", "legendFormat": "rollback/s", "refId": "B"} + ] + }, + { + "type": "timeseries", "title": "PostgreSQL database size", "id": 8, + "gridPos": {"h": 8, "w": 8, "x": 16, "y": 16}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [{"expr": "pg_database_size_bytes{datname=\"messenger\"}", "legendFormat": "database", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Valkey memory", "id": 9, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 24}, + "fieldConfig": {"defaults": {"unit": "bytes"}, "overrides": []}, + "targets": [{"expr": "redis_memory_used_bytes", "legendFormat": "used", "refId": "A"}] + }, + { + "type": "timeseries", "title": "Valkey keys and commands", "id": 10, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 24}, + "targets": [ + {"expr": "sum(redis_db_keys)", "legendFormat": "keys", "refId": "A"}, + {"expr": "rate(redis_commands_processed_total[1m])", "legendFormat": "commands/s", "refId": "B"} + ] + } + ], + "refresh": "5s", + "schemaVersion": 41, + "tags": ["highload", "lab2"], + "templating": {"list": []}, + "time": {"from": "now-15m", "to": "now"}, + "timezone": "browser", + "title": "Messenger overview", + "uid": "messenger-overview", + "version": 1 +} diff --git a/monitoring/grafana/provisioning/dashboards/messenger.yml b/monitoring/grafana/provisioning/dashboards/messenger.yml new file mode 100644 index 0000000..e950d2c --- /dev/null +++ b/monitoring/grafana/provisioning/dashboards/messenger.yml @@ -0,0 +1,10 @@ +apiVersion: 1 + +providers: + - name: Messenger + folder: Highload + type: file + disableDeletion: true + editable: false + options: + path: /var/lib/grafana/dashboards diff --git a/monitoring/grafana/provisioning/datasources/prometheus.yml b/monitoring/grafana/provisioning/datasources/prometheus.yml new file mode 100644 index 0000000..8704d9e --- /dev/null +++ b/monitoring/grafana/provisioning/datasources/prometheus.yml @@ -0,0 +1,10 @@ +apiVersion: 1 + +datasources: + - name: Prometheus + type: prometheus + uid: prometheus + access: proxy + url: http://prometheus:9090 + isDefault: true + editable: false diff --git a/monitoring/prometheus.yml b/monitoring/prometheus.yml new file mode 100644 index 0000000..e23db13 --- /dev/null +++ b/monitoring/prometheus.yml @@ -0,0 +1,16 @@ +global: + scrape_interval: 5s + evaluation_interval: 5s + +scrape_configs: + - job_name: messenger + static_configs: + - targets: ["api:8080"] + + - job_name: postgres + static_configs: + - targets: ["postgres-exporter:9187"] + + - job_name: valkey + static_configs: + - targets: ["valkey-exporter:9121"] diff --git a/scripts/init-local-secrets.sh b/scripts/init-local-secrets.sh new file mode 100755 index 0000000..5f3783c --- /dev/null +++ b/scripts/init-local-secrets.sh @@ -0,0 +1,21 @@ +#!/bin/sh + +set -eu + +if [ -e secrets/postgres_password ] || [ -e secrets/valkey_password ] || [ -e secrets/database_url ] || [ -e secrets/cache_url ] || [ -e secrets/grafana_admin_password ]; then + echo "secrets already exist" >&2 + exit 1 +fi + +umask 077 +mkdir -p secrets + +postgres_password=$(openssl rand -hex 24) +valkey_password=$(openssl rand -hex 24) +grafana_admin_password=$(openssl rand -hex 24) + +printf '%s' "$postgres_password" > secrets/postgres_password +printf '%s' "$valkey_password" > secrets/valkey_password +printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$postgres_password" > secrets/database_url +printf 'redis://default:%s@valkey:6379/0' "$valkey_password" > secrets/cache_url +printf '%s' "$grafana_admin_password" > secrets/grafana_admin_password -- 2.54.0 From 09779a53ae8b53025bea8e402cc3e30f7ed1002b Mon Sep 17 00:00:00 2001 From: dizi Date: Thu, 24 Sep 2026 10:51:15 +0300 Subject: [PATCH 4/5] ci: verify and deploy lab2 --- .gitea/workflows/ci.yml | 87 ++++++++++++++++++++ .gitea/workflows/deploy.yml | 132 +++++++++++++++++++++++++++++++ REPORT.md | 154 ++++++++++++++++++++++++++++++++---- compose.ci.yaml | 63 +++++++++++++++ 4 files changed, 419 insertions(+), 17 deletions(-) create mode 100644 .gitea/workflows/ci.yml create mode 100644 .gitea/workflows/deploy.yml create mode 100644 compose.ci.yaml diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml new file mode 100644 index 0000000..f387c3d --- /dev/null +++ b/.gitea/workflows/ci.yml @@ -0,0 +1,87 @@ +name: CI + +on: + pull_request: + branches: [main] + push: + branches: [main, solution/bvt2303-plastinin] + workflow_dispatch: + +concurrency: + group: ci-${{ github.repository }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + verify: + runs-on: ubuntu-latest + timeout-minutes: 20 + env: + COMPOSE_FILE: compose.ci.yaml + COMPOSE_PROJECT_NAME: mtusi2026lab2-${{ github.run_id }} + steps: + - name: Checkout exact commit + run: | + git init . + git remote add origin https://gitea.privcloud.tech/${{ github.repository }}.git + git fetch --depth=1 origin ${{ github.sha }} + git checkout --detach FETCH_HEAD + + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + cache: false + + - name: Check contract + run: make check + + - name: Validate OpenAPI + run: | + python3 -m venv .venv + .venv/bin/python -m pip install -r requirements-dev.txt + make validate PYTHON=.venv/bin/python + + - name: Check formatting + run: test -z "$(gofmt -l cmd internal migrations)" + + - name: Lint + uses: golangci/golangci-lint-action@v7 + with: + version: v2.13.2 + args: --timeout=5m + skip-cache: true + + - name: Unit tests and build + run: | + go test -race ./... + go build ./cmd/messenger + + - name: Prepare local stack + run: | + cp lab2.env.example .env + docker compose config --quiet + docker compose up -d --build --wait --wait-timeout 120 + network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q api)") + docker network connect "$network" "$HOSTNAME" + printf '%s\n' "$network" > .ci-network + + - name: Public smoke + run: make test BASE_URL=http://api:8080 + + - name: PostgreSQL and Valkey integration tests + run: docker compose --profile tests run --rm --build tests + + - name: Dependency outage recovery + run: go run ./cmd/dependencycheck -base-url=http://api:8080 + + - name: Persistence test + run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://api:8080 + + - name: Container logs + if: failure() + run: if [ -f .env ]; then docker compose logs --no-color --tail=200; fi + + - name: Stop local stack + if: always() + run: | + if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi + if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml new file mode 100644 index 0000000..a18b9fb --- /dev/null +++ b/.gitea/workflows/deploy.yml @@ -0,0 +1,132 @@ +name: Deploy production + +on: + workflow_dispatch: + inputs: + confirmation: + description: Type DEPLOY to release main + required: true + +concurrency: + group: production + cancel-in-progress: false + +jobs: + deploy: + if: github.ref == 'refs/heads/main' && inputs.confirmation == 'DEPLOY' + runs-on: ubuntu-latest + timeout-minutes: 20 + env: + COMPOSE_FILE: compose.ci.yaml + COMPOSE_PROJECT_NAME: mtusi2026lab2-${{ github.run_id }} + steps: + - name: Checkout exact commit + run: | + git init . + git remote add origin https://gitea.privcloud.tech/${{ github.repository }}.git + git fetch --depth=1 origin ${{ github.sha }} + git checkout --detach FETCH_HEAD + + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + cache: false + + - name: Verify release + run: | + make check + python3 -m venv .venv + .venv/bin/python -m pip install -r requirements-dev.txt + make validate PYTHON=.venv/bin/python + test -z "$(gofmt -l cmd internal migrations)" + go test -race ./... + go build ./cmd/messenger + + - name: Lint + uses: golangci/golangci-lint-action@v7 + with: + version: v2.13.2 + args: --timeout=5m + skip-cache: true + + - name: Verify release stack + run: | + cp lab2.env.example .env + docker compose up -d --build --wait --wait-timeout 120 + network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q api)") + docker network connect "$network" "$HOSTNAME" + printf '%s\n' "$network" > .ci-network + make test BASE_URL=http://api:8080 + docker compose --profile tests run --rm --build tests + go run ./cmd/dependencycheck -base-url=http://api:8080 + make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://api:8080 + + - name: Stop release stack + if: always() + run: | + if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi + if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi + + - name: Configure SSH + run: | + install -d -m 700 ~/.ssh + printf '%s\n' '${{ secrets.DEPLOY_SSH_KEY }}' > ~/.ssh/id_ed25519 + chmod 600 ~/.ssh/id_ed25519 + printf '%s\n' '${{ secrets.DEPLOY_KNOWN_HOSTS }}' > ~/.ssh/known_hosts + + - name: Pack release + run: tar --exclude=.git --exclude=.env --exclude=secrets --exclude=.venv -czf /tmp/mtusi-lab2-${{ github.sha }}.tar.gz . + + - name: Upload release + run: scp /tmp/mtusi-lab2-${{ github.sha }}.tar.gz '${{ secrets.DEPLOY_USER }}@${{ secrets.DEPLOY_HOST }}:/tmp/' + + - name: Deploy exact commit + env: + DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }} + DEPLOY_USER: ${{ secrets.DEPLOY_USER }} + RELEASE_SHA: ${{ github.sha }} + RELEASE_ATTEMPT: ${{ github.run_attempt }} + run: | + ssh "$DEPLOY_USER@$DEPLOY_HOST" sh -s -- "$RELEASE_SHA" "$RELEASE_ATTEMPT" <<'REMOTE' + set -eu + + release_sha=$1 + release_attempt=$2 + deploy_root=/opt/mtusi-lab2 + release_dir=$deploy_root/releases/$release_sha-$release_attempt + archive=/tmp/mtusi-lab2-$release_sha.tar.gz + + mkdir -p "$deploy_root/releases" "$deploy_root/shared/backups" + exec 9>"$deploy_root/deploy.lock" + flock -x 9 + + previous= + previous_image= + if [ -L "$deploy_root/current" ]; then + previous=$(basename "$(readlink "$deploy_root/current")") + previous_image=$(cat "$deploy_root/current/.release-sha") + cd "$deploy_root/current" + docker compose -p mtusi-lab2 exec -T postgres sh -eu -c ' + export PGPASSWORD="$(cat /run/secrets/postgres_password)" + pg_dump --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" --format custom + ' > "$deploy_root/shared/backups/pre-$release_sha.dump" + fi + + mkdir -p "$release_dir" + tar -xzf "$archive" -C "$release_dir" + printf '%s\n' "$release_sha" > "$release_dir/.release-sha" + ln -s "$deploy_root/shared/.env" "$release_dir/.env" + ln -s "$deploy_root/shared/secrets" "$release_dir/secrets" + + cd "$release_dir" + if ! API_IMAGE="mtusi-messenger:$release_sha" docker compose -p mtusi-lab2 up -d --build --wait --wait-timeout 120; then + if [ -n "$previous" ]; then + cd "$deploy_root/releases/$previous" + API_IMAGE="mtusi-messenger:$previous_image" docker compose -p mtusi-lab2 up -d --wait --wait-timeout 120 + fi + exit 1 + fi + + ln -sfn "$release_dir" "$deploy_root/current" + rm -f "$archive" + REMOTE diff --git a/REPORT.md b/REPORT.md index e42f2b0..f7874b4 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,157 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Пластинин Денис, БВТ2303 +- Целевая оценка: 5; трек 2 «План запроса и восстановление» +- Ветка: `solution/bvt2303-plastinin`; ссылка на PR указывается при публикации +- Основные библиотеки: pgx v5, valkey-go, x/crypto/argon2, Prometheus client_golang +- Источники: документация PostgreSQL по [транзакциям](https://www.postgresql.org/docs/current/tutorial-transactions.html) и [EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html), документация [Valkey persistence](https://valkey.io/topics/persistence/), [RFC 7617](https://www.rfc-editor.org/info/rfc7617/) +- Помощь ИИ: применялась для анализа задания и проверки реализации; команды и наблюдаемые результаты проверены локально ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требуются Docker с Compose, `make`, Python 3.9 или новее для преподавательских тестов. Go на хосте для обычного запуска не требуется. Версии основных образов закреплены: Go 1.26.5, Alpine 3.24.2, PostgreSQL 17.6, Valkey 8.1.4, Swagger UI 5.31.2. + +```sh +cp lab2.env.example .env +./scripts/init-local-secrets.sh +docker compose config --quiet +docker compose up -d --build --wait --wait-timeout 120 +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +API доступен на `http://localhost:8080`, Swagger UI — на `http://localhost:8081`. Миграции встроены в бинарник и выполняются при запуске до начала приёма запросов. Повторное применение уже записанной версии сверяет checksum и не создаёт объекты повторно. + +Собственные integration-тесты запускаются отдельным профилем: + +```sh +docker compose --profile tests run --rm --build tests +``` + +Мониторинг не входит в обязательный путь запуска и включается явно: + +```sh +docker compose --profile monitoring up -d +``` + +После запуска Prometheus доступен на `http://localhost:9090`, Grafana — на `http://localhost:3000`. Пользователь Grafana — `admin`, пароль хранится только в `secrets/grafana_admin_password`. Дашборд `Highload / Messenger overview` создаётся автоматически. + +Безопасная остановка сохраняет именованные volumes: + +```sh +docker compose --profile monitoring down +``` + +Намеренное удаление всех локальных учебных данных выполняется отдельно: + +```sh +docker compose --profile monitoring down -v +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```mermaid +flowchart LR + C[HTTP client] --> A[Go API] + A --> P[(PostgreSQL)] + A --> V[(Valkey AOF)] + S[Swagger UI] --> A + M[Prometheus] --> A + M --> PE[PostgreSQL exporter] + M --> VE[Valkey exporter] + G[Grafana] --> M +``` + +PostgreSQL является источником истины для пользователей, чатов, участников и сообщений. Внешние ключи не позволяют сообщению ссылаться на отсутствующий чат, пользователя вне чата или удалённое членство. `username` защищён уникальным ограничением базы, поэтому конкурентные запросы не могут создать дубликаты. + +Valkey хранит только сессии. Клиент получает 32 случайных байта в виде opaque Base64URL-токена, а в ключе Valkey используется SHA-256 токена. Значение содержит ID пользователя и срок действия. На ключ устанавливается TTL; logout удаляет ключ. Включены AOF и `appendfsync everysec`, поэтому штатный перезапуск сохраняет сессии. При аварийной остановке граница потери последних изменений AOF составляет примерно одну секунду. + +Пароли хешируются Argon2id с отдельной случайной солью. Basic принимается только на `POST /api/v1/auth/sessions`. Бизнес-ручки принимают Bearer; `X-User-Id` не участвует в аутентификации и не меняет пользователя. Неверный, истёкший или отозванный токен приводит к `401`. Ошибка PostgreSQL или Valkey приводит к `503`, а не к анонимному обходу проверки. + +Создание чата состоит из проверки участников, вставки чата и вставки всех членств в одной транзакции. Любая ошибка вызывает rollback. Все SQL-запросы параметризованы. Пул ограничен переменными `DB_MIN_CONNS` и `DB_MAX_CONNS`, установка соединения и проверки зависимостей имеют таймауты. + +История сообщений использует keyset pagination по `(created_at, id)`. Cursor содержит позицию последней строки, тип ресурса и область чата; сервер проверяет его целостность и принадлежность текущему запросу. Запрос использует индекс `(chat_id, created_at, id)` и не пересчитывает полный offset для каждой страницы. + +Преподавательский `.env.example` сохранён без изменений. Рабочее соответствие параметров находится в `lab2.env.example`: `SESSION_STORE=valkey`, пути Docker secrets задаются Compose, `SESSION_TTL_SECONDS` задаёт срок сессии, `DB_MIN_CONNS`/`DB_MAX_CONNS` ограничивают пул, `DEPENDENCY_TIMEOUT_SECONDS` ограничивает подключение и каждую операцию с зависимостями. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий README | Команда или сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/lab2-verification.txt` | +| Сохранение данных и сессии | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | API, PostgreSQL и Valkey перезапущены; старый токен и подтверждённое сообщение сохранились | `evidence/lab2-verification.txt` | +| Миграции и повторный запуск | повторные сборки и перезапуски API на том же volume | checksum миграции совпал, схема не продублировалась, readiness вернулся в `200` | `evidence/lab2-verification.txt` | +| Гонка username | `docker compose --profile tests run --rm --build tests` | из 8 конкурентных вставок успешна одна, остальные получили conflict | `internal/postgres/store_integration_test.go` | +| Rollback чата | тот же integration suite | неизвестный участник дал `ErrInvalidMembers`, число чатов не изменилось | `internal/postgres/store_integration_test.go` | +| TTL и logout | integration suite и `make test` | сессия исчезла после TTL; после logout запрос и повторный logout дали `401` | `internal/session/session_integration_test.go` | +| Неверный пароль и отказ зависимостей | `go test -race ./internal/messenger` | неверный пароль — `401`; ошибки PostgreSQL и Valkey — `503` | `internal/messenger/server_test.go` | +| Реальный отказ зависимостей | `go run ./cmd/dependencycheck` | поочерёдный stop PostgreSQL/Valkey дал `503`; после up восстановились readiness и старый токен | `evidence/lab2-verification.txt` | +| Индекс истории | Go-эксперимент, 100 000 сообщений, `EXPLAIN (ANALYZE, BUFFERS)` | составной индекс: 0,069 мс и 0 отфильтрованных строк; глобальный индекс: 0,597 мс и 1900 отфильтрованных строк | `evidence/lab2-track2.json` | +| Стоимость записи | 5 повторов `CopyFrom` по 10 000 строк, медиана | без вторичного индекса 309 172 строк/с; составной 286 011 строк/с; снижение около 7,5% | `evidence/lab2-track2.json` | +| Backup и restore | `./scripts/backup-restore.sh` | восстановление в `messenger_restore` за 1 с; counts, memberships и digest полей сообщений совпали | `evidence/lab2-backup-restore.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Эксперимент с планом запроса -## Эксперименты и отказы +Гипотеза: индекс `(chat_id, created_at, id)` ускорит keyset pagination в небольшом чате относительно индекса `(created_at, id)`, потому что PostgreSQL сможет сразу ограничить диапазон конкретным `chat_id`. Цена улучшения — дополнительное обслуживание более широкого индекса при записи и место на диске. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Эксперимент выполнен Go-программой `cmd/lab2experiment`. Среда обезличена: контейнер `linux/arm64`, Go 1.26.5, лимит 2 CPU. Создано 100 000 синтетических сообщений в 20 чатах с распределением 60 000, 20 000, 10 000 и от 588 до 592 сообщений в остальных чатах. Времена сообщений разных чатов чередуются, поэтому глобальный индекс не получает преимущества от последовательной загрузки одного чата. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +Проверялся запрос страницы из 100 сообщений после cursor в середине одного из небольших чатов. Для каждого варианта индекс пересоздавался, выполнялся `ANALYZE`, затем сохранялся полный JSON-план `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`. + +| Вариант | Execution time | Строк отброшено фильтром | Shared blocks hit/read | +| --- | ---: | ---: | ---: | +| `(chat_id, created_at, id)` | 0,069 мс | 0 | 6 / 4 | +| `(created_at, id)` | 0,597 мс | 1900 | 1994 / 19 | + +В данной точке составной индекс быстрее примерно в 8,7 раза. Причина видна в плане: он сразу выбирает диапазон одного чата, а глобальный индекс идёт по общей временной шкале и проверяет `chat_id` для чужих сообщений. + +Стоимость записи измерялась отдельно. Для каждого варианта таблица создавалась заново, пять раз загружалось по 10 000 одинаково сформированных строк, в отчёт взята медиана. + +| Вариант | Медиана | Производительность | Размер вторичного индекса | +| --- | ---: | ---: | ---: | +| без вторичного индекса | 0,0323 с | 309 172 строк/с | 0 | +| `(chat_id, created_at, id)` | 0,0350 с | 286 011 строк/с | 991 232 байта | +| `(created_at, id)` | 0,0350 с | 285 326 строк/с | 425 984 байта | + +Составной индекс выбран для приложения: потеря около 7,5% в синтетической пакетной записи компенсируется существенным ускорением основной операции чтения истории. Эти числа относятся к прогретой локальной среде, короткому запуску и 100 000 строк; они показывают направление и не являются производственным SLA. + +## Backup, восстановление и отказы + +`scripts/backup-restore.sh` создаёт временный backup PostgreSQL в custom format, создаёт новую базу `messenger_restore`, выполняет `pg_restore`, затем сравнивает counts пользователей, чатов, членств и сообщений. Для десяти выбранных сообщений сравнивается digest полей `id`, `chat_id`, `sender_id`, `text` и `created_at`. Dump удаляется после проверки и не попадает в Git. + +В проверенном запуске восстановлены 35 пользователей, 9 чатов, 17 членств и 8 сообщений; digest совпал, полное время сценария составило 1 секунду. RPO равен моменту snapshot, который видит `pg_dump`: транзакции, зафиксированные после начала snapshot, не входят в этот backup. RTO в 1 секунду относится к малому учебному набору; с ростом объёма он увеличится. + +| Воздействие | Ожидаемое поведение | Наблюдение | Восстановление и потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| штатный restart API, PostgreSQL и Valkey | readiness временно недоступен, затем старые данные и токен читаются | persistence-тест прошёл | автоматическое восстановление; подтверждённые данные не потеряны | +| недоступен PostgreSQL | readiness и операции с данными возвращают `503` | реальный контейнер остановлен; после запуска прежний токен снова сработал | после возврата БД; анонимный доступ не разрешается | +| недоступен Valkey | readiness и Bearer-аутентификация возвращают `503` | реальный контейнер остановлен; после запуска AOF восстановил прежний токен | после возврата Valkey; запрос не считается аутентифицированным | +| истёк TTL или logout | токен возвращает `401` | integration и public smoke прошли | повторный login создаёт новую сессию | +| restore из backup | новая БД содержит снимок исходной | counts, memberships и message digest совпали | 1 с на учебном наборе; RPO равен snapshot | + +## CI/CD и мониторинг + +`.gitea/workflows/ci.yml` запускается для PR в `main`, push в solution/main и вручную. Он проверяет контракт, OpenAPI, форматирование, golangci-lint, race unit-тесты, сборку, public smoke, реальные PostgreSQL/Valkey integration-тесты и persistence. + +Production deployment вынесен в `.gitea/workflows/deploy.yml`. Gitea 1.27 не поддерживает обязательное подтверждение environment, поэтому подтверждением служит ручной `workflow_dispatch` со строкой `DEPLOY`. Workflow разрешает только ветку `main` и для exact SHA повторяет OpenAPI, lint, race, smoke, integration, реальный dependency outage и persistence. После зелёных проверок он делает backup, создаёт release-каталог по SHA и номеру попытки и выполняет health check. Для включения требуются repository secrets `DEPLOY_HOST`, `DEPLOY_USER`, `DEPLOY_SSH_KEY`, `DEPLOY_KNOWN_HOSTS`; на сервере заранее создаются `/opt/mtusi-lab2/shared/.env` и `/opt/mtusi-lab2/shared/secrets`. + +Профиль monitoring собирает метрики без пользовательских ID и raw URL в labels. Дашборд содержит RPS, классы HTTP-ответов, p95, in-flight, Go heap, соединения и транзакции PostgreSQL, размер БД, память, ключи и команды Valkey. Мониторинг не участвует в readiness приложения. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Стенд содержит одну API-реплику. Горизонтальное масштабирование и idempotency появляются в лабораторной 3. +- Локальный HTTP не шифруется. На сервере Basic и Bearer должны передаваться только через TLS reverse proxy; это будет частью эксплуатационной защиты последующих лабораторных. +- Valkey AOF `everysec` сохраняет сессии при штатном рестарте, но допускает потерю примерно последней секунды при аварии процесса или узла. +- PostgreSQL `COMMIT` подтверждает фиксацию согласно `synchronous_commit`, `fsync` и надёжности диска. Он не заменяет внешние backup и репликацию. +- Exporters в локальном профиле используют учебные credentials сервисов. Для production следует создать отдельного пользователя PostgreSQL с ролью `pg_monitor` и ограничить сетевой доступ к Prometheus/Grafana. +- Эксперимент измеряет один запрос и короткие локальные серии. Для production нужны длительные прогоны, несколько объёмов данных, холодный cache, конкурентное чтение и запись. + +## Ответы на вопросы защиты + +`COMMIT` делает изменения транзакции видимыми как единое целое и фиксирует их согласно настройкам durability PostgreSQL. Гарантия пережить отказ зависит от `fsync`, `synchronous_commit`, WAL и физического хранилища. + +Сессии находятся в Valkey. TTL удаляет истёкшие ключи, logout удаляет ключ немедленно. AOF сохраняет их при рестарте; `FLUSHDB` удалит сессии, после чего клиенты должны войти заново. + +Аутентификация отвечает на вопрос, кто выполняет запрос: Bearer-токен связывается с пользователем. Авторизация дополнительно проверяет членство пользователя в конкретном чате. Валидная сессия не даёт доступ к чужому чату. + +Argon2id намеренно медленный и требует память, поэтому усложняет перебор паролей. Быстрый checksum предназначен для обнаружения случайного изменения данных и не подходит для хранения паролей. diff --git a/compose.ci.yaml b/compose.ci.yaml new file mode 100644 index 0000000..0f17d66 --- /dev/null +++ b/compose.ci.yaml @@ -0,0 +1,63 @@ +services: + postgres: + image: postgres:17.6-alpine3.22 + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD: ci-postgres-password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + + valkey: + image: valkey/valkey:8.1.4-alpine + command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--requirepass", "ci-valkey-password"] + volumes: + - valkey_data:/data + healthcheck: + test: ["CMD", "valkey-cli", "--no-auth-warning", "-a", "ci-valkey-password", "ping"] + interval: 5s + timeout: 3s + retries: 20 + + api: + build: . + env_file: .env + entrypoint: ["/bin/sh", "-eu", "-c"] + command: + - | + printf '%s' "$$DATABASE_URL" > /tmp/database_url + printf '%s' "$$CACHE_URL" > /tmp/cache_url + exec /app/messenger + environment: + DATABASE_URL: postgres://messenger:ci-postgres-password@postgres:5432/messenger?sslmode=disable + DATABASE_URL_FILE: /tmp/database_url + CACHE_URL: redis://default:ci-valkey-password@valkey:6379/0 + CACHE_URL_FILE: /tmp/cache_url + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + + tests: + profiles: ["tests"] + build: + context: . + target: test + environment: + TEST_DATABASE_URL: postgres://messenger:ci-postgres-password@postgres:5432/messenger?sslmode=disable + TEST_CACHE_URL: redis://default:ci-valkey-password@valkey:6379/0 + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + +volumes: + postgres_data: + valkey_data: -- 2.54.0 From 6d5ac9e81da992e9ee06b72924b5aabaa7a9b59a Mon Sep 17 00:00:00 2001 From: dizi Date: Fri, 25 Sep 2026 11:28:13 +0300 Subject: [PATCH 5/5] fix: address review comments --- .gitea/workflows/ci.yml | 24 +- .gitea/workflows/deploy.yml | 142 +++--------- Dockerfile | 14 ++ REPORT.md | 60 +++-- cmd/lab2experiment/main.go | 9 +- cmd/messenger/main.go | 34 +-- cmd/messenger/main_test.go | 28 --- compose.ci.yaml | 63 ------ compose.yaml | 98 +++----- go.mod | 12 +- go.sum | 23 +- internal/config/config.go | 209 +++++++++++------- internal/database/database.go | 31 ++- internal/logger/logger.go | 10 + internal/messenger/auth.go | 113 ++++++++++ internal/messenger/handlers.go | 110 +-------- ...dependencies.go => messenger_interface.go} | 4 +- internal/messenger/server.go | 28 +-- internal/messenger/server_test.go | 46 ++-- internal/model/model.go | 47 ++-- internal/password/password.go | 141 +++++++----- internal/password/password_test.go | 15 +- lab2.env.example | 55 ++++- .../provisioning/dashboards/messenger.yml | 2 +- scripts/backup-restore.sh | 10 +- scripts/init-local-secrets.sh | 21 -- 26 files changed, 683 insertions(+), 666 deletions(-) delete mode 100644 cmd/messenger/main_test.go delete mode 100644 compose.ci.yaml create mode 100644 internal/logger/logger.go create mode 100644 internal/messenger/auth.go rename internal/messenger/{dependencies.go => messenger_interface.go} (94%) delete mode 100755 scripts/init-local-secrets.sh diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index f387c3d..7ea1207 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -4,7 +4,7 @@ on: pull_request: branches: [main] push: - branches: [main, solution/bvt2303-plastinin] + branches: [main] workflow_dispatch: concurrency: @@ -16,8 +16,11 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 20 env: - COMPOSE_FILE: compose.ci.yaml COMPOSE_PROJECT_NAME: mtusi2026lab2-${{ github.run_id }} + API_BIND_ADDRESS: 127.0.0.1:0 + SWAGGER_BIND_ADDRESS: 127.0.0.1:0 + PROMETHEUS_BIND_ADDRESS: 127.0.0.1:0 + GRAFANA_BIND_ADDRESS: 127.0.0.1:0 steps: - name: Checkout exact commit run: | @@ -64,17 +67,12 @@ jobs: docker network connect "$network" "$HOSTNAME" printf '%s\n' "$network" > .ci-network - - name: Public smoke - run: make test BASE_URL=http://api:8080 - - - name: PostgreSQL and Valkey integration tests - run: docker compose --profile tests run --rm --build tests - - - name: Dependency outage recovery - run: go run ./cmd/dependencycheck -base-url=http://api:8080 - - - name: Persistence test - run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://api:8080 + - name: Integration checks + run: | + make test BASE_URL=http://api:8080 + docker compose --profile tests run --rm --build tests + go run ./cmd/dependencycheck -base-url=http://api:8080 + make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://api:8080 - name: Container logs if: failure() diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml index a18b9fb..5439df8 100644 --- a/.gitea/workflows/deploy.yml +++ b/.gitea/workflows/deploy.yml @@ -1,11 +1,8 @@ name: Deploy production on: - workflow_dispatch: - inputs: - confirmation: - description: Type DEPLOY to release main - required: true + push: + branches: [main] concurrency: group: production @@ -13,120 +10,31 @@ concurrency: jobs: deploy: - if: github.ref == 'refs/heads/main' && inputs.confirmation == 'DEPLOY' + name: Deploy to server runs-on: ubuntu-latest - timeout-minutes: 20 - env: - COMPOSE_FILE: compose.ci.yaml - COMPOSE_PROJECT_NAME: mtusi2026lab2-${{ github.run_id }} steps: - - name: Checkout exact commit - run: | - git init . - git remote add origin https://gitea.privcloud.tech/${{ github.repository }}.git - git fetch --depth=1 origin ${{ github.sha }} - git checkout --detach FETCH_HEAD - - - uses: actions/setup-go@v5 + - name: Deploy + uses: appleboy/ssh-action@master with: - go-version-file: go.mod - cache: false + host: ${{ secrets.DEPLOY_HOST }} + username: ${{ secrets.DEPLOY_USER }} + key: ${{ secrets.DEPLOY_SSH_KEY }} + script: | + cd ~/mtusi2026lab2 + git fetch origin main + git reset --hard origin/main + git clean -fd + docker compose down + docker compose build + docker compose up -d --wait --wait-timeout 120 - - name: Verify release - run: | - make check - python3 -m venv .venv - .venv/bin/python -m pip install -r requirements-dev.txt - make validate PYTHON=.venv/bin/python - test -z "$(gofmt -l cmd internal migrations)" - go test -race ./... - go build ./cmd/messenger - - - name: Lint - uses: golangci/golangci-lint-action@v7 + - name: Verify deployment + uses: appleboy/ssh-action@master with: - version: v2.13.2 - args: --timeout=5m - skip-cache: true - - - name: Verify release stack - run: | - cp lab2.env.example .env - docker compose up -d --build --wait --wait-timeout 120 - network=$(docker inspect --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{end}}' "$(docker compose ps -q api)") - docker network connect "$network" "$HOSTNAME" - printf '%s\n' "$network" > .ci-network - make test BASE_URL=http://api:8080 - docker compose --profile tests run --rm --build tests - go run ./cmd/dependencycheck -base-url=http://api:8080 - make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://api:8080 - - - name: Stop release stack - if: always() - run: | - if [ -f .ci-network ]; then docker network disconnect "$(cat .ci-network)" "$HOSTNAME"; fi - if [ -f .env ]; then docker compose --profile tests down -v --remove-orphans; fi - - - name: Configure SSH - run: | - install -d -m 700 ~/.ssh - printf '%s\n' '${{ secrets.DEPLOY_SSH_KEY }}' > ~/.ssh/id_ed25519 - chmod 600 ~/.ssh/id_ed25519 - printf '%s\n' '${{ secrets.DEPLOY_KNOWN_HOSTS }}' > ~/.ssh/known_hosts - - - name: Pack release - run: tar --exclude=.git --exclude=.env --exclude=secrets --exclude=.venv -czf /tmp/mtusi-lab2-${{ github.sha }}.tar.gz . - - - name: Upload release - run: scp /tmp/mtusi-lab2-${{ github.sha }}.tar.gz '${{ secrets.DEPLOY_USER }}@${{ secrets.DEPLOY_HOST }}:/tmp/' - - - name: Deploy exact commit - env: - DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }} - DEPLOY_USER: ${{ secrets.DEPLOY_USER }} - RELEASE_SHA: ${{ github.sha }} - RELEASE_ATTEMPT: ${{ github.run_attempt }} - run: | - ssh "$DEPLOY_USER@$DEPLOY_HOST" sh -s -- "$RELEASE_SHA" "$RELEASE_ATTEMPT" <<'REMOTE' - set -eu - - release_sha=$1 - release_attempt=$2 - deploy_root=/opt/mtusi-lab2 - release_dir=$deploy_root/releases/$release_sha-$release_attempt - archive=/tmp/mtusi-lab2-$release_sha.tar.gz - - mkdir -p "$deploy_root/releases" "$deploy_root/shared/backups" - exec 9>"$deploy_root/deploy.lock" - flock -x 9 - - previous= - previous_image= - if [ -L "$deploy_root/current" ]; then - previous=$(basename "$(readlink "$deploy_root/current")") - previous_image=$(cat "$deploy_root/current/.release-sha") - cd "$deploy_root/current" - docker compose -p mtusi-lab2 exec -T postgres sh -eu -c ' - export PGPASSWORD="$(cat /run/secrets/postgres_password)" - pg_dump --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" --format custom - ' > "$deploy_root/shared/backups/pre-$release_sha.dump" - fi - - mkdir -p "$release_dir" - tar -xzf "$archive" -C "$release_dir" - printf '%s\n' "$release_sha" > "$release_dir/.release-sha" - ln -s "$deploy_root/shared/.env" "$release_dir/.env" - ln -s "$deploy_root/shared/secrets" "$release_dir/secrets" - - cd "$release_dir" - if ! API_IMAGE="mtusi-messenger:$release_sha" docker compose -p mtusi-lab2 up -d --build --wait --wait-timeout 120; then - if [ -n "$previous" ]; then - cd "$deploy_root/releases/$previous" - API_IMAGE="mtusi-messenger:$previous_image" docker compose -p mtusi-lab2 up -d --wait --wait-timeout 120 - fi - exit 1 - fi - - ln -sfn "$release_dir" "$deploy_root/current" - rm -f "$archive" - REMOTE + host: ${{ secrets.DEPLOY_HOST }} + username: ${{ secrets.DEPLOY_USER }} + key: ${{ secrets.DEPLOY_SSH_KEY }} + script: | + cd ~/mtusi2026lab2 + git log --oneline -3 + docker compose ps diff --git a/Dockerfile b/Dockerfile index 166dd09..361ff16 100644 --- a/Dockerfile +++ b/Dockerfile @@ -12,6 +12,20 @@ FROM build AS experiment CMD ["go", "run", "./cmd/lab2experiment"] +FROM swaggerapi/swagger-ui:v5.31.2 AS swagger + +COPY contracts/openapi.json /spec/openapi.json +ENV SWAGGER_JSON=/spec/openapi.json + +FROM prom/prometheus:v3.13.3 AS prometheus + +COPY monitoring/prometheus.yml /etc/prometheus/prometheus.yml + +FROM grafana/grafana:13.1.6 AS grafana + +COPY monitoring/grafana/provisioning /etc/grafana/provisioning +COPY monitoring/grafana/dashboards /etc/grafana/dashboards + FROM alpine:3.24.2 RUN addgroup -S app && adduser -S -G app -u 10001 app diff --git a/REPORT.md b/REPORT.md index f7874b4..fd10649 100644 --- a/REPORT.md +++ b/REPORT.md @@ -3,9 +3,8 @@ - Автор, группа: Пластинин Денис, БВТ2303 - Целевая оценка: 5; трек 2 «План запроса и восстановление» - Ветка: `solution/bvt2303-plastinin`; ссылка на PR указывается при публикации -- Основные библиотеки: pgx v5, valkey-go, x/crypto/argon2, Prometheus client_golang +- Основные библиотеки: pgx v5, valkey-go, Viper, x/crypto/argon2, Prometheus client_golang - Источники: документация PostgreSQL по [транзакциям](https://www.postgresql.org/docs/current/tutorial-transactions.html) и [EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html), документация [Valkey persistence](https://valkey.io/topics/persistence/), [RFC 7617](https://www.rfc-editor.org/info/rfc7617/) -- Помощь ИИ: применялась для анализа задания и проверки реализации; команды и наблюдаемые результаты проверены локально ## Запуск из чистого clone @@ -13,7 +12,6 @@ ```sh cp lab2.env.example .env -./scripts/init-local-secrets.sh docker compose config --quiet docker compose up -d --build --wait --wait-timeout 120 make test @@ -28,24 +26,18 @@ API доступен на `http://localhost:8080`, Swagger UI — на `http://l docker compose --profile tests run --rm --build tests ``` -Мониторинг не входит в обязательный путь запуска и включается явно: - -```sh -docker compose --profile monitoring up -d -``` - -После запуска Prometheus доступен на `http://localhost:9090`, Grafana — на `http://localhost:3000`. Пользователь Grafana — `admin`, пароль хранится только в `secrets/grafana_admin_password`. Дашборд `Highload / Messenger overview` создаётся автоматически. +Основной Compose одновременно запускает API, PostgreSQL, Valkey, Swagger UI, exporters, Prometheus и Grafana. Prometheus доступен на `http://localhost:9090`, Grafana — на `http://localhost:3000`. Пользователь Grafana — `admin`, пароль задаётся в локальном `.env`. Дашборд `Highload / Messenger overview` создаётся автоматически. Безопасная остановка сохраняет именованные volumes: ```sh -docker compose --profile monitoring down +docker compose down ``` Намеренное удаление всех локальных учебных данных выполняется отдельно: ```sh -docker compose --profile monitoring down -v +docker compose down -v ``` ## Архитектура и решения @@ -62,6 +54,40 @@ flowchart LR G[Grafana] --> M ``` +Схема базы данных: + +```mermaid +erDiagram + users ||--o{ chat_members : participates + chats ||--|{ chat_members : contains + chat_members ||--o{ messages : allows_sender + + users { + uuid id PK + text username UK + text display_name + text password_hash + timestamptz created_at + } + chats { + uuid id PK + text title + timestamptz created_at + } + chat_members { + uuid chat_id PK,FK + uuid user_id PK,FK + smallint position + } + messages { + uuid id PK + uuid chat_id FK + uuid sender_id FK + text text + timestamptz created_at + } +``` + PostgreSQL является источником истины для пользователей, чатов, участников и сообщений. Внешние ключи не позволяют сообщению ссылаться на отсутствующий чат, пользователя вне чата или удалённое членство. `username` защищён уникальным ограничением базы, поэтому конкурентные запросы не могут создать дубликаты. Valkey хранит только сессии. Клиент получает 32 случайных байта в виде opaque Base64URL-токена, а в ключе Valkey используется SHA-256 токена. Значение содержит ID пользователя и срок действия. На ключ устанавливается TTL; logout удаляет ключ. Включены AOF и `appendfsync everysec`, поэтому штатный перезапуск сохраняет сессии. При аварийной остановке граница потери последних изменений AOF составляет примерно одну секунду. @@ -72,7 +98,7 @@ Valkey хранит только сессии. Клиент получает 32 История сообщений использует keyset pagination по `(created_at, id)`. Cursor содержит позицию последней строки, тип ресурса и область чата; сервер проверяет его целостность и принадлежность текущему запросу. Запрос использует индекс `(chat_id, created_at, id)` и не пересчитывает полный offset для каждой страницы. -Преподавательский `.env.example` сохранён без изменений. Рабочее соответствие параметров находится в `lab2.env.example`: `SESSION_STORE=valkey`, пути Docker secrets задаются Compose, `SESSION_TTL_SECONDS` задаёт срок сессии, `DB_MIN_CONNS`/`DB_MAX_CONNS` ограничивают пул, `DEPENDENCY_TIMEOUT_SECONDS` ограничивает подключение и каждую операцию с зависимостями. +Преподавательский `.env.example` сохранён без изменений. Рабочие параметры находятся в `lab2.env.example`; каждое поле снабжено пояснением. Viper читает настройки из окружения и завершает запуск с ошибкой, если обязательного значения нет. В репозитории находятся только учебные значения, а серверный `.env` хранится вне Git. ## Доказательства критериев @@ -131,11 +157,11 @@ Valkey хранит только сессии. Клиент получает 32 ## CI/CD и мониторинг -`.gitea/workflows/ci.yml` запускается для PR в `main`, push в solution/main и вручную. Он проверяет контракт, OpenAPI, форматирование, golangci-lint, race unit-тесты, сборку, public smoke, реальные PostgreSQL/Valkey integration-тесты и persistence. +`.gitea/workflows/ci.yml` запускается для PR в `main`, push в `main` и вручную. Он проверяет контракт, OpenAPI, форматирование, golangci-lint, race unit-тесты, сборку, public smoke, реальные PostgreSQL/Valkey integration-тесты и persistence. -Production deployment вынесен в `.gitea/workflows/deploy.yml`. Gitea 1.27 не поддерживает обязательное подтверждение environment, поэтому подтверждением служит ручной `workflow_dispatch` со строкой `DEPLOY`. Workflow разрешает только ветку `main` и для exact SHA повторяет OpenAPI, lint, race, smoke, integration, реальный dependency outage и persistence. После зелёных проверок он делает backup, создаёт release-каталог по SHA и номеру попытки и выполняет health check. Для включения требуются repository secrets `DEPLOY_HOST`, `DEPLOY_USER`, `DEPLOY_SSH_KEY`, `DEPLOY_KNOWN_HOSTS`; на сервере заранее создаются `/opt/mtusi-lab2/shared/.env` и `/opt/mtusi-lab2/shared/secrets`. +`.gitea/workflows/deploy.yml` запускается после push в защищённую ветку `main`. Через `appleboy/ssh-action` он обновляет серверный clone до `origin/main`, пересобирает единый Compose-стек и выводит состояние контейнеров. Для запуска требуются repository secrets `DEPLOY_HOST`, `DEPLOY_USER`, `DEPLOY_SSH_KEY`; на сервере заранее создаются каталог `~/mtusi2026lab2` и локальный `.env` с рабочими паролями. -Профиль monitoring собирает метрики без пользовательских ID и raw URL в labels. Дашборд содержит RPS, классы HTTP-ответов, p95, in-flight, Go heap, соединения и транзакции PostgreSQL, размер БД, память, ключи и команды Valkey. Мониторинг не участвует в readiness приложения. +Мониторинг собирает метрики без пользовательских ID и raw URL в labels. Дашборд содержит RPS, классы HTTP-ответов, p95, in-flight, Go heap, соединения и транзакции PostgreSQL, размер БД, память, ключи и команды Valkey. Мониторинг не участвует в readiness приложения. ## Ограничения и следующие шаги @@ -143,7 +169,7 @@ Production deployment вынесен в `.gitea/workflows/deploy.yml`. Gitea 1.2 - Локальный HTTP не шифруется. На сервере Basic и Bearer должны передаваться только через TLS reverse proxy; это будет частью эксплуатационной защиты последующих лабораторных. - Valkey AOF `everysec` сохраняет сессии при штатном рестарте, но допускает потерю примерно последней секунды при аварии процесса или узла. - PostgreSQL `COMMIT` подтверждает фиксацию согласно `synchronous_commit`, `fsync` и надёжности диска. Он не заменяет внешние backup и репликацию. -- Exporters в локальном профиле используют учебные credentials сервисов. Для production следует создать отдельного пользователя PostgreSQL с ролью `pg_monitor` и ограничить сетевой доступ к Prometheus/Grafana. +- Exporters в локальном Compose используют учебные credentials сервисов. Для production следует создать отдельного пользователя PostgreSQL с ролью `pg_monitor` и ограничить сетевой доступ к Prometheus/Grafana. - Эксперимент измеряет один запрос и короткие локальные серии. Для production нужны длительные прогоны, несколько объёмов данных, холодный cache, конкурентное чтение и запись. ## Ответы на вопросы защиты diff --git a/cmd/lab2experiment/main.go b/cmd/lab2experiment/main.go index ac4f781..7f38907 100644 --- a/cmd/lab2experiment/main.go +++ b/cmd/lab2experiment/main.go @@ -54,7 +54,7 @@ func main() { } func run() error { - urlFile := flag.String("database-url-file", "secrets/database_url", "file containing the PostgreSQL URL") + databaseURL := flag.String("database-url", os.Getenv("DATABASE_URL"), "PostgreSQL URL") output := flag.String("output", "evidence/lab2-track2.json", "result JSON path") messages := flag.Int("messages", 100000, "number of messages") writeRows := flag.Int("write-rows", 10000, "rows per write test") @@ -66,11 +66,10 @@ func run() error { return fmt.Errorf("write-rows must be at least 1000") } - data, err := os.ReadFile(*urlFile) - if err != nil { - return fmt.Errorf("read database URL: %w", err) + if strings.TrimSpace(*databaseURL) == "" { + return fmt.Errorf("database URL is required") } - pool, err := pgxpool.New(context.Background(), strings.TrimSpace(string(data))) + pool, err := pgxpool.New(context.Background(), strings.TrimSpace(*databaseURL)) if err != nil { return fmt.Errorf("open database: %w", err) } diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go index 0754e73..8341bce 100644 --- a/cmd/messenger/main.go +++ b/cmd/messenger/main.go @@ -8,10 +8,10 @@ import ( "os" "os/signal" "syscall" - "time" "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/config" "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/database" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/logger" "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/messenger" "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/password" "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" @@ -19,9 +19,9 @@ import ( ) func main() { - logger := slog.New(slog.NewJSONHandler(os.Stdout, nil)) - if err := run(logger); err != nil { - logger.Error("server stopped", "error", err) + appLogger := logger.New() + if err := run(appLogger); err != nil { + appLogger.Error("server stopped", "error", err) os.Exit(1) } } @@ -33,9 +33,9 @@ func run(logger *slog.Logger) error { } pool, err := database.Open(context.Background(), database.Config{ URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, - MaxConnectionAge: 30 * time.Minute, MaxConnectionIdle: 5 * time.Minute, - HealthCheckPeriod: 30 * time.Second, ConnectTimeout: settings.ConnectTimeout, - MigrationTimeout: 30 * time.Second, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + MigrationTimeout: settings.MigrationTimeout, }) if err != nil { return err @@ -46,11 +46,19 @@ func run(logger *slog.Logger) error { 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 + } app := messenger.NewServer( logger, postgres.New(pool), sessions, - password.Hasher{}, + passwords, settings.SessionTTL, settings.RequestTimeout, settings.SwaggerPort, @@ -58,10 +66,10 @@ func run(logger *slog.Logger) error { server := &http.Server{ Addr: settings.Address, Handler: app.Handler(), - ReadHeaderTimeout: 5 * time.Second, - ReadTimeout: 10 * time.Second, - WriteTimeout: settings.RequestTimeout + 5*time.Second, - IdleTimeout: 60 * time.Second, + ReadHeaderTimeout: settings.HTTPReadHeaderTimeout, + ReadTimeout: settings.HTTPReadTimeout, + WriteTimeout: settings.HTTPWriteTimeout, + IdleTimeout: settings.HTTPIdleTimeout, } listener, err := net.Listen("tcp", server.Addr) if err != nil { @@ -80,7 +88,7 @@ func run(logger *slog.Logger) error { case <-ctx.Done(): logger.Info("shutdown requested") app.SetReady(false) - shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + shutdownCtx, cancel := context.WithTimeout(context.Background(), settings.HTTPShutdownTimeout) defer cancel() if err := server.Shutdown(shutdownCtx); err != nil { _ = server.Close() diff --git a/cmd/messenger/main_test.go b/cmd/messenger/main_test.go deleted file mode 100644 index 71ec372..0000000 --- a/cmd/messenger/main_test.go +++ /dev/null @@ -1,28 +0,0 @@ -package main - -import ( - "strings" - "testing" -) - -func TestRunRequiresAddress(t *testing.T) { - tests := []struct { - name string - host string - port string - want string - }{ - {name: "missing host", port: "8080", want: "APP_HOST is required"}, - {name: "missing port", host: "127.0.0.1", want: "APP_PORT is required"}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - t.Setenv("APP_HOST", tt.host) - t.Setenv("APP_PORT", tt.port) - if err := run(nil); err == nil || !strings.Contains(err.Error(), tt.want) { - t.Fatalf("run() error = %v, want %q", err, tt.want) - } - }) - } -} diff --git a/compose.ci.yaml b/compose.ci.yaml deleted file mode 100644 index 0f17d66..0000000 --- a/compose.ci.yaml +++ /dev/null @@ -1,63 +0,0 @@ -services: - postgres: - image: postgres:17.6-alpine3.22 - environment: - POSTGRES_USER: messenger - POSTGRES_DB: messenger - POSTGRES_PASSWORD: ci-postgres-password - volumes: - - postgres_data:/var/lib/postgresql/data - healthcheck: - test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] - interval: 5s - timeout: 3s - retries: 20 - - valkey: - image: valkey/valkey:8.1.4-alpine - command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--requirepass", "ci-valkey-password"] - volumes: - - valkey_data:/data - healthcheck: - test: ["CMD", "valkey-cli", "--no-auth-warning", "-a", "ci-valkey-password", "ping"] - interval: 5s - timeout: 3s - retries: 20 - - api: - build: . - env_file: .env - entrypoint: ["/bin/sh", "-eu", "-c"] - command: - - | - printf '%s' "$$DATABASE_URL" > /tmp/database_url - printf '%s' "$$CACHE_URL" > /tmp/cache_url - exec /app/messenger - environment: - DATABASE_URL: postgres://messenger:ci-postgres-password@postgres:5432/messenger?sslmode=disable - DATABASE_URL_FILE: /tmp/database_url - CACHE_URL: redis://default:ci-valkey-password@valkey:6379/0 - CACHE_URL_FILE: /tmp/cache_url - depends_on: - postgres: - condition: service_healthy - valkey: - condition: service_healthy - - tests: - profiles: ["tests"] - build: - context: . - target: test - environment: - TEST_DATABASE_URL: postgres://messenger:ci-postgres-password@postgres:5432/messenger?sslmode=disable - TEST_CACHE_URL: redis://default:ci-valkey-password@valkey:6379/0 - depends_on: - postgres: - condition: service_healthy - valkey: - condition: service_healthy - -volumes: - postgres_data: - valkey_data: diff --git a/compose.yaml b/compose.yaml index ea9a8dd..e5b65f9 100644 --- a/compose.yaml +++ b/compose.yaml @@ -4,9 +4,7 @@ services: environment: POSTGRES_USER: ${POSTGRES_USER} POSTGRES_DB: ${POSTGRES_DB} - POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password - secrets: - - postgres_password + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} volumes: - postgres_data:/var/lib/postgresql/data healthcheck: @@ -20,16 +18,13 @@ services: valkey: image: valkey/valkey:8.1.4-alpine - command: - - sh - - -c - - exec valkey-server --appendonly yes --appendfsync everysec --requirepass "$$(cat /run/secrets/valkey_password)" - secrets: - - valkey_password + command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--requirepass", "${VALKEY_PASSWORD}"] + environment: + VALKEY_PASSWORD: ${VALKEY_PASSWORD} volumes: - valkey_data:/data healthcheck: - test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(cat /run/secrets/valkey_password)\" ping | grep -q PONG"] + test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$VALKEY_PASSWORD\" ping | grep -q PONG"] interval: 5s timeout: 3s retries: 20 @@ -41,14 +36,8 @@ services: build: . image: ${API_IMAGE:-mtusi-messenger:lab2} env_file: .env - environment: - DATABASE_URL_FILE: /run/secrets/database_url - CACHE_URL_FILE: /run/secrets/cache_url - secrets: - - database_url - - cache_url ports: - - "127.0.0.1:8080:${APP_PORT}" + - "${API_BIND_ADDRESS}:${APP_PORT}" depends_on: postgres: condition: service_healthy @@ -60,13 +49,11 @@ services: restart: unless-stopped swagger: - image: swaggerapi/swagger-ui:v5.31.2 - environment: - SWAGGER_JSON: /spec/openapi.json - volumes: - - ./contracts/openapi.json:/spec/openapi.json:ro + build: + context: . + target: swagger ports: - - "127.0.0.1:${SWAGGER_PORT}:8080" + - "${SWAGGER_BIND_ADDRESS}:8080" depends_on: api: condition: service_healthy @@ -78,11 +65,8 @@ services: context: . target: test environment: - TEST_DATABASE_URL_FILE: /run/secrets/database_url - TEST_CACHE_URL_FILE: /run/secrets/cache_url - secrets: - - database_url - - cache_url + TEST_DATABASE_URL: ${DATABASE_URL} + TEST_CACHE_URL: ${CACHE_URL} depends_on: postgres: condition: service_healthy @@ -94,14 +78,8 @@ services: build: context: . target: experiment - command: - - go - - run - - ./cmd/lab2experiment - - -database-url-file=/run/secrets/database_url - - -output=/output/lab2-track2.json - secrets: - - database_url + env_file: .env + command: ["go", "run", "./cmd/lab2experiment", "-output=/output/lab2-track2.json"] volumes: - ./evidence:/output depends_on: @@ -109,45 +87,40 @@ services: condition: service_healthy postgres-exporter: - profiles: ["monitoring"] image: quay.io/prometheuscommunity/postgres-exporter:v0.20.1 environment: DATA_SOURCE_URI: postgres:5432/${POSTGRES_DB}?sslmode=disable DATA_SOURCE_USER: ${POSTGRES_USER} - DATA_SOURCE_PASS_FILE: /run/secrets/postgres_password + DATA_SOURCE_PASS: ${POSTGRES_PASSWORD} PG_EXPORTER_COLLECTION_TIMEOUT: 5s - secrets: - - postgres_password depends_on: postgres: condition: service_healthy restart: unless-stopped valkey-exporter: - profiles: ["monitoring"] image: oliver006/redis_exporter:v1.89.0-alpine - entrypoint: ["/bin/sh", "-c"] - command: - - export REDIS_PASSWORD="$$(cat /run/secrets/valkey_password)"; exec /redis_exporter --redis.addr=redis://valkey:6379 --redis.user=default --connection-timeout=5s - secrets: - - valkey_password + environment: + REDIS_ADDR: redis://valkey:6379 + REDIS_USER: default + REDIS_PASSWORD: ${VALKEY_PASSWORD} depends_on: valkey: condition: service_healthy restart: unless-stopped prometheus: - profiles: ["monitoring"] - image: prom/prometheus:v3.13.3 + build: + context: . + target: prometheus command: - --config.file=/etc/prometheus/prometheus.yml - --storage.tsdb.path=/prometheus - --storage.tsdb.retention.time=7d volumes: - - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro - prometheus_data:/prometheus ports: - - "127.0.0.1:${PROMETHEUS_PORT}:9090" + - "${PROMETHEUS_BIND_ADDRESS}:9090" depends_on: - api - postgres-exporter @@ -155,36 +128,21 @@ services: restart: unless-stopped grafana: - profiles: ["monitoring"] - image: grafana/grafana:13.1.6 + build: + context: . + target: grafana environment: GF_SECURITY_ADMIN_USER: admin - GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password + GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD} GF_USERS_ALLOW_SIGN_UP: "false" - secrets: - - grafana_admin_password volumes: - - ./monitoring/grafana/provisioning:/etc/grafana/provisioning:ro - - ./monitoring/grafana/dashboards:/var/lib/grafana/dashboards:ro - grafana_data:/var/lib/grafana ports: - - "127.0.0.1:${GRAFANA_PORT}:3000" + - "${GRAFANA_BIND_ADDRESS}:3000" depends_on: - prometheus restart: unless-stopped -secrets: - postgres_password: - file: ./secrets/postgres_password - valkey_password: - file: ./secrets/valkey_password - database_url: - file: ./secrets/database_url - cache_url: - file: ./secrets/cache_url - grafana_admin_password: - file: ./secrets/grafana_admin_password - volumes: postgres_data: valkey_data: diff --git a/go.mod b/go.mod index c773449..87b3785 100644 --- a/go.mod +++ b/go.mod @@ -6,6 +6,7 @@ require ( github.com/google/uuid v1.6.0 github.com/jackc/pgx/v5 v5.11.0 github.com/prometheus/client_golang v1.23.2 + github.com/spf13/viper v1.21.0 github.com/valkey-io/valkey-go v1.0.78 golang.org/x/crypto v0.57.0 ) @@ -13,15 +14,24 @@ require ( require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/fsnotify/fsnotify v1.9.0 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect - github.com/kr/text v0.2.0 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.66.1 // indirect github.com/prometheus/procfs v0.16.1 // indirect + github.com/sagikazarmark/locafero v0.11.0 // indirect + github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect + github.com/spf13/afero v1.15.0 // indirect + github.com/spf13/cast v1.10.0 // indirect + github.com/spf13/pflag v1.0.10 // indirect + github.com/subosito/gotenv v1.6.0 // indirect go.yaml.in/yaml/v2 v2.4.2 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sync v0.23.0 // indirect golang.org/x/sys v0.48.0 // indirect golang.org/x/text v0.42.0 // indirect diff --git a/go.sum b/go.sum index e2cb534..e55a574 100644 --- a/go.sum +++ b/go.sum @@ -2,10 +2,15 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= +github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= @@ -30,6 +35,8 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/onsi/gomega v1.42.1 h1:iN1rCUX+44NZ1Dc97MPoeFYbFR0vh8zxoxMFwKdyZ6I= github.com/onsi/gomega v1.42.1/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg= +github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= +github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= @@ -42,11 +49,25 @@ github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzM github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc= +github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik= +github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw= +github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= +github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I= +github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= +github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY= +github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo= +github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= +github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU= +github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= github.com/valkey-io/valkey-go v1.0.78 h1:1Ce8hRaaNXpKfqmqZQRhnbVh1eW8MGR873pdXVvE4y8= github.com/valkey-io/valkey-go v1.0.78/go.mod h1:gvC/r2m3eW4Hbj0YnjogTzNtFdPSM/D+NCqen+5OABM= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= diff --git a/internal/config/config.go b/internal/config/config.go index 644cad8..4804110 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -4,145 +4,206 @@ import ( "errors" "fmt" "net" - "os" "strconv" "strings" "time" + + "github.com/spf13/viper" ) type Config struct { - Address string - DatabaseURL string - CacheURL string - SessionTTL time.Duration - DBMaxConns int32 - DBMinConns int32 - ConnectTimeout time.Duration - RequestTimeout time.Duration - SwaggerPort string + Address string + DatabaseURL string + CacheURL string + SessionTTL time.Duration + DBMaxConns int32 + DBMinConns int32 + DBMaxConnectionAge time.Duration + DBMaxConnectionIdle time.Duration + DBHealthCheckPeriod time.Duration + DependencyTimeout time.Duration + MigrationTimeout time.Duration + RequestTimeout time.Duration + HTTPReadHeaderTimeout time.Duration + HTTPReadTimeout time.Duration + HTTPWriteTimeout time.Duration + HTTPIdleTimeout time.Duration + HTTPShutdownTimeout time.Duration + PasswordMemoryKiB uint32 + PasswordIterations uint32 + PasswordParallelism uint8 + PasswordSaltLength uint32 + PasswordKeyLength uint32 + SwaggerPort string } func Load() (Config, error) { - host, err := requiredEnv("APP_HOST") + values := viper.New() + values.AutomaticEnv() + + host, err := requiredString(values, "APP_HOST") if err != nil { return Config{}, err } - port, err := requiredPort("APP_PORT") + port, err := requiredPort(values, "APP_PORT") if err != nil { return Config{}, err } - databaseURL, err := secretFromEnv("DATABASE_URL_FILE") + databaseURL, err := requiredString(values, "DATABASE_URL") if err != nil { return Config{}, err } - cacheURL, err := secretFromEnv("CACHE_URL_FILE") + cacheURL, err := requiredString(values, "CACHE_URL") if err != nil { return Config{}, err } - if store, err := requiredEnv("SESSION_STORE"); err != nil { + store, err := requiredString(values, "SESSION_STORE") + if err != nil { return Config{}, err - } else if store != "valkey" { + } + if store != "valkey" { return Config{}, errors.New("SESSION_STORE must be valkey") } - ttlSeconds, err := requiredPositiveInt("SESSION_TTL_SECONDS") + + sessionTTL, err := seconds(values, "SESSION_TTL_SECONDS", 1, 86400*30) if err != nil { return Config{}, err } - maxConns, err := intEnv("DB_MAX_CONNS", 10, 1, 100) + maxConns, err := integer(values, "DB_MAX_CONNS", 1, 100) if err != nil { return Config{}, err } - minConns, err := intEnv("DB_MIN_CONNS", 1, 0, maxConns) + minConns, err := integer(values, "DB_MIN_CONNS", 0, maxConns) if err != nil { return Config{}, err } - connectSeconds, err := intEnv("DEPENDENCY_TIMEOUT_SECONDS", 5, 1, 60) + maxConnectionAge, err := seconds(values, "DB_MAX_CONNECTION_AGE_SECONDS", 1, 86400) if err != nil { return Config{}, err } - swaggerPort := os.Getenv("SWAGGER_PORT") - if swaggerPort == "" { - swaggerPort = "8081" + maxConnectionIdle, err := seconds(values, "DB_MAX_CONNECTION_IDLE_SECONDS", 1, 86400) + if err != nil { + return Config{}, err } - if _, err := parsePort(swaggerPort); err != nil { - return Config{}, fmt.Errorf("SWAGGER_PORT: %w", err) + healthCheckPeriod, err := seconds(values, "DB_HEALTH_CHECK_SECONDS", 1, 3600) + if err != nil { + return Config{}, err } + dependencyTimeout, err := seconds(values, "DEPENDENCY_TIMEOUT_SECONDS", 1, 60) + if err != nil { + return Config{}, err + } + migrationTimeout, err := seconds(values, "MIGRATION_TIMEOUT_SECONDS", 1, 600) + if err != nil { + return Config{}, err + } + requestTimeout, err := seconds(values, "REQUEST_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + readHeaderTimeout, err := seconds(values, "HTTP_READ_HEADER_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + readTimeout, err := seconds(values, "HTTP_READ_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + writeTimeout, err := seconds(values, "HTTP_WRITE_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + idleTimeout, err := seconds(values, "HTTP_IDLE_TIMEOUT_SECONDS", 1, 3600) + if err != nil { + return Config{}, err + } + shutdownTimeout, err := seconds(values, "HTTP_SHUTDOWN_TIMEOUT_SECONDS", 1, 300) + if err != nil { + return Config{}, err + } + passwordMemory, err := integer(values, "PASSWORD_MEMORY_KIB", 8*1024, 1024*1024) + if err != nil { + return Config{}, err + } + passwordIterations, err := integer(values, "PASSWORD_ITERATIONS", 1, 20) + if err != nil { + return Config{}, err + } + passwordParallelism, err := integer(values, "PASSWORD_PARALLELISM", 1, 255) + if err != nil { + return Config{}, err + } + passwordSaltLength, err := integer(values, "PASSWORD_SALT_LENGTH", 8, 1024) + if err != nil { + return Config{}, err + } + passwordKeyLength, err := integer(values, "PASSWORD_KEY_LENGTH", 16, 1024) + if err != nil { + return Config{}, err + } + swaggerPort, err := requiredPort(values, "SWAGGER_PORT") + if err != nil { + return Config{}, err + } + return Config{ - Address: net.JoinHostPort(host, port), - DatabaseURL: databaseURL, - CacheURL: cacheURL, - SessionTTL: time.Duration(ttlSeconds) * time.Second, - DBMaxConns: int32(maxConns), - DBMinConns: int32(minConns), - ConnectTimeout: time.Duration(connectSeconds) * time.Second, - RequestTimeout: time.Duration(connectSeconds) * time.Second, - SwaggerPort: swaggerPort, + Address: net.JoinHostPort(host, port), DatabaseURL: databaseURL, CacheURL: cacheURL, + SessionTTL: sessionTTL, DBMaxConns: int32(maxConns), DBMinConns: int32(minConns), + DBMaxConnectionAge: maxConnectionAge, DBMaxConnectionIdle: maxConnectionIdle, + DBHealthCheckPeriod: healthCheckPeriod, DependencyTimeout: dependencyTimeout, + MigrationTimeout: migrationTimeout, RequestTimeout: requestTimeout, + HTTPReadHeaderTimeout: readHeaderTimeout, HTTPReadTimeout: readTimeout, + HTTPWriteTimeout: writeTimeout, HTTPIdleTimeout: idleTimeout, + HTTPShutdownTimeout: shutdownTimeout, PasswordMemoryKiB: uint32(passwordMemory), + PasswordIterations: uint32(passwordIterations), PasswordParallelism: uint8(passwordParallelism), + PasswordSaltLength: uint32(passwordSaltLength), PasswordKeyLength: uint32(passwordKeyLength), + SwaggerPort: swaggerPort, }, nil } -func requiredEnv(name string) (string, error) { - value := strings.TrimSpace(os.Getenv(name)) +func requiredString(values *viper.Viper, name string) (string, error) { + value := strings.TrimSpace(values.GetString(name)) if value == "" { return "", fmt.Errorf("%s is required", name) } return value, nil } -func requiredPort(name string) (string, error) { - value, err := requiredEnv(name) +func requiredPort(values *viper.Viper, name string) (string, error) { + value, err := requiredString(values, name) if err != nil { return "", err } - if _, err := parsePort(value); err != nil { + if _, err := integerValue(value, 1, 65535); err != nil { return "", fmt.Errorf("%s: %w", name, err) } return value, nil } -func parsePort(value string) (int, error) { - port, err := strconv.Atoi(value) - if err != nil || port < 1 || port > 65535 { - return 0, errors.New("must be between 1 and 65535") - } - return port, nil -} - -func requiredPositiveInt(name string) (int, error) { - value, err := requiredEnv(name) +func seconds(values *viper.Viper, name string, minimum, maximum int) (time.Duration, error) { + value, err := integer(values, name, minimum, maximum) if err != nil { return 0, err } - parsed, err := strconv.Atoi(value) - if err != nil || parsed <= 0 { - return 0, fmt.Errorf("%s must be a positive integer", name) + return time.Duration(value) * time.Second, nil +} + +func integer(values *viper.Viper, name string, minimum, maximum int) (int, error) { + value, err := requiredString(values, name) + if err != nil { + return 0, err + } + parsed, err := integerValue(value, minimum, maximum) + if err != nil { + return 0, fmt.Errorf("%s: %w", name, err) } return parsed, nil } -func intEnv(name string, fallback, minimum, maximum int) (int, error) { - value := os.Getenv(name) - if value == "" { - return fallback, nil - } +func integerValue(value string, minimum, maximum int) (int, error) { parsed, err := strconv.Atoi(value) if err != nil || parsed < minimum || parsed > maximum { - return 0, fmt.Errorf("%s must be between %d and %d", name, minimum, maximum) + return 0, fmt.Errorf("must be between %d and %d", minimum, maximum) } return parsed, nil } - -func secretFromEnv(name string) (string, error) { - path, err := requiredEnv(name) - if err != nil { - return "", err - } - data, err := os.ReadFile(path) - if err != nil { - return "", fmt.Errorf("read %s: %w", name, err) - } - value := strings.TrimSpace(string(data)) - if value == "" { - return "", fmt.Errorf("%s points to an empty file", name) - } - return value, nil -} diff --git a/internal/database/database.go b/internal/database/database.go index 10b0eda..a690415 100644 --- a/internal/database/database.go +++ b/internal/database/database.go @@ -2,6 +2,7 @@ package database import ( "context" + "errors" "fmt" "time" @@ -10,6 +11,18 @@ import ( "gitea.privcloud.tech/dizi/mtusi2026lab2/migrations" ) +var ( + errURLRequired = errors.New("database URL is required") + errMinConnections = errors.New("minimum database connections must not be negative") + errMaxConnections = errors.New("maximum database connections must be positive") + errConnectionRange = errors.New("minimum database connections exceed maximum") + errMaxConnectionAge = errors.New("maximum database connection age must be positive") + errMaxConnectionIdle = errors.New("maximum database connection idle time must be positive") + errHealthCheckPeriod = errors.New("database health check period must be positive") + errConnectionTimeout = errors.New("database connection timeout must be positive") + errMigrationTimeout = errors.New("database migration timeout must be positive") +) + type Config struct { URL string MinConnections int32 @@ -58,23 +71,23 @@ func Open(ctx context.Context, config Config) (*pgxpool.Pool, error) { func validateConfig(config Config) error { switch { case config.URL == "": - return fmt.Errorf("database URL is required") + return errURLRequired case config.MinConnections < 0: - return fmt.Errorf("minimum database connections must not be negative") + return errMinConnections case config.MaxConnections < 1: - return fmt.Errorf("maximum database connections must be positive") + return errMaxConnections case config.MinConnections > config.MaxConnections: - return fmt.Errorf("minimum database connections exceed maximum") + return errConnectionRange case config.MaxConnectionAge <= 0: - return fmt.Errorf("maximum database connection age must be positive") + return errMaxConnectionAge case config.MaxConnectionIdle <= 0: - return fmt.Errorf("maximum database connection idle time must be positive") + return errMaxConnectionIdle case config.HealthCheckPeriod <= 0: - return fmt.Errorf("database health check period must be positive") + return errHealthCheckPeriod case config.ConnectTimeout <= 0: - return fmt.Errorf("database connection timeout must be positive") + return errConnectionTimeout case config.MigrationTimeout <= 0: - return fmt.Errorf("database migration timeout must be positive") + return errMigrationTimeout default: return nil } diff --git a/internal/logger/logger.go b/internal/logger/logger.go new file mode 100644 index 0000000..ab81366 --- /dev/null +++ b/internal/logger/logger.go @@ -0,0 +1,10 @@ +package logger + +import ( + "log/slog" + "os" +) + +func New() *slog.Logger { + return slog.New(slog.NewJSONHandler(os.Stdout, nil)) +} diff --git a/internal/messenger/auth.go b/internal/messenger/auth.go new file mode 100644 index 0000000..5bf621d --- /dev/null +++ b/internal/messenger/auth.go @@ -0,0 +1,113 @@ +package messenger + +import ( + "errors" + "io" + "net/http" + "strings" + + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" + "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" +) + +func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodPost { + return methodNotAllowed(w, http.MethodPost) + } + body, err := io.ReadAll(io.LimitReader(r.Body, 1)) + if err != nil || len(body) != 0 { + return invalidRequest() + } + username, passwordValue, ok := singleBasicAuth(r) + if !ok { + return unauthorized() + } + credentials, err := s.messengerStore.UserByUsername(r.Context(), username) + if errors.Is(err, postgres.ErrNotFound) { + if _, verifyErr := s.passwords.Verify(passwordValue, s.passwords.DummyHash()); verifyErr != nil { + return internalError() + } + return unauthorized() + } + if err != nil { + return unavailable() + } + verified, err := s.passwords.Verify(passwordValue, credentials.PasswordHash) + if err != nil { + return internalError() + } + if !verified { + return unauthorized() + } + token, expiresAt, err := s.sessions.Create(r.Context(), credentials.ID, s.sessionTTL) + if err != nil { + return unavailable() + } + writeJSON(w, http.StatusCreated, struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User User `json:"user"` + }{token, "Bearer", model.FormatTime(expiresAt), credentials.User}) + return nil +} + +func singleBasicAuth(r *http.Request) (string, string, bool) { + if len(r.Header.Values("Authorization")) != 1 { + return "", "", false + } + username, passwordValue, ok := r.BasicAuth() + return username, passwordValue, ok && username != "" +} + +func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) *apiError { + if r.Method != http.MethodDelete { + return methodNotAllowed(w, http.MethodDelete) + } + _, token, authErr := s.authenticate(r) + if authErr != nil { + return authErr + } + if err := s.sessions.Delete(r.Context(), token); errors.Is(err, session.ErrNotFound) { + return unauthorized() + } else if err != nil { + return unavailable() + } + w.WriteHeader(http.StatusNoContent) + return nil +} + +func (s *Server) authenticate(r *http.Request) (User, string, *apiError) { + values := r.Header.Values("Authorization") + if len(values) != 1 { + return User{}, "", unauthorized() + } + scheme, token, found := strings.Cut(values[0], " ") + if !found || !strings.EqualFold(scheme, "Bearer") || token == "" || strings.ContainsAny(token, " \t\r\n") { + return User{}, "", unauthorized() + } + userID, err := s.sessions.UserID(r.Context(), token) + if errors.Is(err, session.ErrNotFound) || errors.Is(err, session.ErrInvalidToken) { + return User{}, "", unauthorized() + } + if err != nil { + return User{}, "", unavailable() + } + user, err := s.messengerStore.UserByID(r.Context(), userID) + if errors.Is(err, postgres.ErrNotFound) { + _ = s.sessions.Delete(r.Context(), token) + return User{}, "", unauthorized() + } + if err != nil { + return User{}, "", unavailable() + } + return user, token, nil +} + +func authenticationChallenge(r *http.Request) string { + if r.URL.Path == "/api/v1/auth/sessions" { + return `Basic realm="messenger", charset="UTF-8"` + } + return `Bearer realm="messenger"` +} diff --git a/internal/messenger/handlers.go b/internal/messenger/handlers.go index 0100db7..1b0fc9b 100644 --- a/internal/messenger/handlers.go +++ b/internal/messenger/handlers.go @@ -3,7 +3,6 @@ package messenger import ( "context" "errors" - "io" "net/http" "regexp" "strings" @@ -12,7 +11,6 @@ import ( "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/postgres" - "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/session" ) var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) @@ -34,7 +32,7 @@ func (s *Server) readiness(w http.ResponseWriter, r *http.Request) *apiError { } ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) defer cancel() - if err := s.repository.Ping(ctx); err != nil { + if err := s.messengerStore.Ping(ctx); err != nil { return unavailable() } if err := s.sessions.Ping(ctx); err != nil { @@ -63,7 +61,7 @@ func (s *Server) users(w http.ResponseWriter, r *http.Request) *apiError { if err != nil { return internalError() } - user, err := s.repository.CreateUser(r.Context(), input.Username, input.DisplayName, passwordHash) + user, err := s.messengerStore.CreateUser(r.Context(), input.Username, input.DisplayName, passwordHash) if errors.Is(err, postgres.ErrConflict) { return &apiError{http.StatusConflict, errorCodeConflict, "username already exists"} } @@ -79,73 +77,6 @@ func validPassword(value string) bool { return utf8.ValidString(value) && strings.TrimSpace(value) != "" && length >= 12 && length <= 128 } -func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError { - if r.Method != http.MethodPost { - return methodNotAllowed(w, http.MethodPost) - } - body, err := io.ReadAll(io.LimitReader(r.Body, 1)) - if err != nil || len(body) != 0 { - return invalidRequest() - } - username, passwordValue, ok := singleBasicAuth(r) - if !ok { - return unauthorized() - } - credentials, err := s.repository.UserByUsername(r.Context(), username) - if errors.Is(err, postgres.ErrNotFound) { - if _, verifyErr := s.passwords.Verify(passwordValue, s.passwords.DummyHash()); verifyErr != nil { - return internalError() - } - return unauthorized() - } - if err != nil { - return unavailable() - } - verified, err := s.passwords.Verify(passwordValue, credentials.PasswordHash) - if err != nil { - return internalError() - } - if !verified { - return unauthorized() - } - token, expiresAt, err := s.sessions.Create(r.Context(), credentials.ID, s.sessionTTL) - if err != nil { - return unavailable() - } - writeJSON(w, http.StatusCreated, struct { - Token string `json:"token"` - TokenType string `json:"token_type"` - ExpiresAt string `json:"expires_at"` - User User `json:"user"` - }{token, "Bearer", model.FormatTime(expiresAt), credentials.User}) - return nil -} - -func singleBasicAuth(r *http.Request) (string, string, bool) { - if len(r.Header.Values("Authorization")) != 1 { - return "", "", false - } - username, passwordValue, ok := r.BasicAuth() - return username, passwordValue, ok && username != "" -} - -func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) *apiError { - if r.Method != http.MethodDelete { - return methodNotAllowed(w, http.MethodDelete) - } - _, token, authErr := s.authenticate(r) - if authErr != nil { - return authErr - } - if err := s.sessions.Delete(r.Context(), token); errors.Is(err, session.ErrNotFound) { - return unauthorized() - } else if err != nil { - return unavailable() - } - w.WriteHeader(http.StatusNoContent) - return nil -} - func (s *Server) me(w http.ResponseWriter, r *http.Request) *apiError { if r.Method != http.MethodGet { return methodNotAllowed(w, http.MethodGet) @@ -194,7 +125,7 @@ func (s *Server) chats(w http.ResponseWriter, r *http.Request) *apiError { if _, included := members[user.ID]; !included { return invalidRequest() } - chat, err := s.repository.CreateChat(r.Context(), input.Title, input.MemberIDs, user.ID) + chat, err := s.messengerStore.CreateChat(r.Context(), input.Title, input.MemberIDs, user.ID) if errors.Is(err, postgres.ErrInvalidMembers) { return invalidRequest() } @@ -210,7 +141,7 @@ func (s *Server) listChats(w http.ResponseWriter, r *http.Request, user User) *a if err != nil { return err } - items, hasNext, listErr := s.repository.ListChats(r.Context(), user.ID, cursorPosition(cursor), limit) + items, hasNext, listErr := s.messengerStore.ListChats(r.Context(), user.ID, cursorPosition(cursor), limit) if errors.Is(listErr, postgres.ErrInvalidCursor) { return invalidRequest() } @@ -245,7 +176,7 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) *apiError { if !valid { return invalidRequest() } - chat, err := s.repository.ChatForUser(r.Context(), chatID, user.ID) + chat, err := s.messengerStore.ChatForUser(r.Context(), chatID, user.ID) if errors.Is(err, postgres.ErrNotFound) { return notFound() } @@ -280,7 +211,7 @@ func (s *Server) messages(w http.ResponseWriter, r *http.Request) *apiError { if !validText(input.Text, 4000) { return invalidRequest() } - message, err := s.repository.CreateMessage(r.Context(), chatID, user.ID, input.Text) + message, err := s.messengerStore.CreateMessage(r.Context(), chatID, user.ID, input.Text) if errors.Is(err, postgres.ErrNotFound) { return notFound() } @@ -296,7 +227,7 @@ func (s *Server) listMessages(w http.ResponseWriter, r *http.Request, user User, if err != nil { return err } - items, hasNext, listErr := s.repository.ListMessages(r.Context(), chatID, user.ID, cursorPosition(cursor), limit) + items, hasNext, listErr := s.messengerStore.ListMessages(r.Context(), chatID, user.ID, cursorPosition(cursor), limit) if errors.Is(listErr, postgres.ErrNotFound) { return notFound() } @@ -328,30 +259,3 @@ func cursorPosition(cursor *pageCursor) *model.Position { } return &model.Position{CreatedAt: cursor.Time, ID: cursor.ID} } - -func (s *Server) authenticate(r *http.Request) (User, string, *apiError) { - values := r.Header.Values("Authorization") - if len(values) != 1 { - return User{}, "", unauthorized() - } - scheme, token, found := strings.Cut(values[0], " ") - if !found || !strings.EqualFold(scheme, "Bearer") || token == "" || strings.ContainsAny(token, " \t\r\n") { - return User{}, "", unauthorized() - } - userID, err := s.sessions.UserID(r.Context(), token) - if errors.Is(err, session.ErrNotFound) || errors.Is(err, session.ErrInvalidToken) { - return User{}, "", unauthorized() - } - if err != nil { - return User{}, "", unavailable() - } - user, err := s.repository.UserByID(r.Context(), userID) - if errors.Is(err, postgres.ErrNotFound) { - _ = s.sessions.Delete(r.Context(), token) - return User{}, "", unauthorized() - } - if err != nil { - return User{}, "", unavailable() - } - return user, token, nil -} diff --git a/internal/messenger/dependencies.go b/internal/messenger/messenger_interface.go similarity index 94% rename from internal/messenger/dependencies.go rename to internal/messenger/messenger_interface.go index f2fbadd..ed56628 100644 --- a/internal/messenger/dependencies.go +++ b/internal/messenger/messenger_interface.go @@ -7,7 +7,7 @@ import ( "gitea.privcloud.tech/dizi/mtusi2026lab2/internal/model" ) -type Repository interface { +type MessengerStore interface { Ping(context.Context) error CreateUser(context.Context, string, string, string) (model.User, error) UserByID(context.Context, string) (model.User, error) @@ -26,7 +26,7 @@ type SessionStore interface { Delete(context.Context, string) error } -type Passwords interface { +type PasswordService interface { Hash(string) (string, error) Verify(string, string) (bool, error) DummyHash() string diff --git a/internal/messenger/server.go b/internal/messenger/server.go index 33a4fd7..da676b9 100644 --- a/internal/messenger/server.go +++ b/internal/messenger/server.go @@ -9,15 +9,15 @@ import ( ) type Server struct { - repository Repository - sessions SessionStore - passwords Passwords - sessionTTL time.Duration - requestTTL time.Duration - logger *slog.Logger - swaggerPort string - metrics *metrics - ready atomic.Bool + messengerStore MessengerStore + sessions SessionStore + passwords PasswordService + sessionTTL time.Duration + requestTTL time.Duration + logger *slog.Logger + swaggerPort string + metrics *metrics + ready atomic.Bool } type statusWriter struct { @@ -30,9 +30,9 @@ func (w *statusWriter) WriteHeader(status int) { w.ResponseWriter.WriteHeader(status) } -func NewServer(logger *slog.Logger, repository Repository, sessions SessionStore, passwords Passwords, sessionTTL, requestTTL time.Duration, swaggerPort string) *Server { +func NewServer(logger *slog.Logger, messages MessengerStore, sessions SessionStore, passwords PasswordService, sessionTTL, requestTTL time.Duration, swaggerPort string) *Server { s := &Server{ - repository: repository, sessions: sessions, passwords: passwords, + messengerStore: messages, sessions: sessions, passwords: passwords, sessionTTL: sessionTTL, requestTTL: requestTTL, logger: logger, swaggerPort: swaggerPort, metrics: newMetrics(), } s.ready.Store(true) @@ -80,11 +80,7 @@ func (s *Server) serve(w http.ResponseWriter, r *http.Request) { r = r.WithContext(ctx) if apiErr := s.route(wrapped, r); apiErr != nil { if apiErr.status == http.StatusUnauthorized { - challenge := `Bearer realm="messenger"` - if r.URL.Path == "/api/v1/auth/sessions" { - challenge = `Basic realm="messenger", charset="UTF-8"` - } - wrapped.Header().Set("WWW-Authenticate", challenge) + wrapped.Header().Set("WWW-Authenticate", authenticationChallenge(r)) } writeError(wrapped, requestID, apiErr) } diff --git a/internal/messenger/server_test.go b/internal/messenger/server_test.go index 641a779..9d521c9 100644 --- a/internal/messenger/server_test.go +++ b/internal/messenger/server_test.go @@ -16,7 +16,7 @@ import ( var errDependency = errors.New("dependency unavailable") -type repositoryStub struct { +type messengerStoreStub struct { pingErr error userByID model.User userByIDErr error @@ -24,29 +24,29 @@ type repositoryStub struct { credentialsErr error } -func (s repositoryStub) Ping(context.Context) error { return s.pingErr } -func (repositoryStub) CreateUser(context.Context, string, string, string) (model.User, error) { +func (s messengerStoreStub) Ping(context.Context) error { return s.pingErr } +func (messengerStoreStub) CreateUser(context.Context, string, string, string) (model.User, error) { return model.User{}, nil } -func (s repositoryStub) UserByID(context.Context, string) (model.User, error) { +func (s messengerStoreStub) UserByID(context.Context, string) (model.User, error) { return s.userByID, s.userByIDErr } -func (s repositoryStub) UserByUsername(context.Context, string) (model.UserCredentials, error) { +func (s messengerStoreStub) UserByUsername(context.Context, string) (model.UserCredentials, error) { return s.credentials, s.credentialsErr } -func (repositoryStub) CreateChat(context.Context, string, []string, string) (model.Chat, error) { +func (messengerStoreStub) CreateChat(context.Context, string, []string, string) (model.Chat, error) { return model.Chat{}, nil } -func (repositoryStub) ChatForUser(context.Context, string, string) (model.Chat, error) { +func (messengerStoreStub) ChatForUser(context.Context, string, string) (model.Chat, error) { return model.Chat{}, nil } -func (repositoryStub) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) { +func (messengerStoreStub) ListChats(context.Context, string, *model.Position, int) ([]model.Chat, bool, error) { return nil, false, nil } -func (repositoryStub) CreateMessage(context.Context, string, string, string) (model.Message, error) { +func (messengerStoreStub) CreateMessage(context.Context, string, string, string) (model.Message, error) { return model.Message{}, nil } -func (repositoryStub) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) { +func (messengerStoreStub) ListMessages(context.Context, string, string, *model.Position, int) ([]model.Message, bool, error) { return nil, false, nil } @@ -77,16 +77,16 @@ func (s passwordsStub) Verify(string, string) (bool, error) { func TestReadinessReturnsUnavailableForDependencyFailure(t *testing.T) { tests := []struct { name string - repo repositoryStub + store messengerStoreStub sessions sessionStub }{ - {name: "postgres", repo: repositoryStub{pingErr: errDependency}}, + {name: "postgres", store: messengerStoreStub{pingErr: errDependency}}, {name: "valkey", sessions: sessionStub{pingErr: errDependency}}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - server := newTestServer(tt.repo, tt.sessions, passwordsStub{}) + server := newTestServer(tt.store, tt.sessions, passwordsStub{}) response := serveRequest(server, http.MethodGet, "/health/ready", "") if response.Code != http.StatusServiceUnavailable { t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) @@ -98,16 +98,16 @@ func TestReadinessReturnsUnavailableForDependencyFailure(t *testing.T) { func TestBusinessRequestReturnsUnavailableForDependencyFailure(t *testing.T) { tests := []struct { name string - repo repositoryStub + store messengerStoreStub sessions sessionStub }{ {name: "valkey", sessions: sessionStub{userIDErr: errDependency}}, - {name: "postgres", repo: repositoryStub{userByIDErr: errDependency}, sessions: sessionStub{userID: "user-id"}}, + {name: "postgres", store: messengerStoreStub{userByIDErr: errDependency}, sessions: sessionStub{userID: "user-id"}}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - server := newTestServer(tt.repo, tt.sessions, passwordsStub{}) + server := newTestServer(tt.store, tt.sessions, passwordsStub{}) request := httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil) request.Header.Set("Authorization", "Bearer valid-token") response := httptest.NewRecorder() @@ -120,14 +120,14 @@ func TestBusinessRequestReturnsUnavailableForDependencyFailure(t *testing.T) { } func TestAuthenticationChallenges(t *testing.T) { - server := newTestServer(repositoryStub{}, sessionStub{}, passwordsStub{}) + server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) bearer := serveRequest(server, http.MethodGet, "/api/v1/users/me", "") if bearer.Code != http.StatusUnauthorized || bearer.Header().Get("WWW-Authenticate") != `Bearer realm="messenger"` { t.Fatalf("business challenge = %d %q", bearer.Code, bearer.Header().Get("WWW-Authenticate")) } - repository := repositoryStub{credentials: model.UserCredentials{PasswordHash: "hash"}} - server = newTestServer(repository, sessionStub{}, passwordsStub{verified: false}) + store := messengerStoreStub{credentials: model.UserCredentials{PasswordHash: "hash"}} + server = newTestServer(store, sessionStub{}, passwordsStub{verified: false}) request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", nil) request.SetBasicAuth("user", "wrong-password") response := httptest.NewRecorder() @@ -138,7 +138,7 @@ func TestAuthenticationChallenges(t *testing.T) { } func TestSessionCreationRejectsChunkedBody(t *testing.T) { - server := newTestServer(repositoryStub{}, sessionStub{}, passwordsStub{}) + server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", strings.NewReader("{}")) request.ContentLength = -1 request.SetBasicAuth("user", "password") @@ -150,16 +150,16 @@ func TestSessionCreationRejectsChunkedBody(t *testing.T) { } func TestRegistrationRejectsWhitespacePassword(t *testing.T) { - server := newTestServer(repositoryStub{}, sessionStub{}, passwordsStub{}) + server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) response := serveRequest(server, http.MethodPost, "/api/v1/users", `{"username":"student","display_name":"Student","password":" "}`) if response.Code != http.StatusBadRequest { t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) } } -func newTestServer(repository Repository, sessions SessionStore, passwords Passwords) *Server { +func newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { logger := slog.New(slog.NewTextHandler(io.Discard, nil)) - return NewServer(logger, repository, sessions, passwords, time.Hour, time.Second, "8081") + return NewServer(logger, messages, sessions, passwords, time.Hour, time.Second, "8081") } func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { diff --git a/internal/model/model.go b/internal/model/model.go index 65a5edb..57a247e 100644 --- a/internal/model/model.go +++ b/internal/model/model.go @@ -39,35 +39,38 @@ type Position struct { ID string } +type userJSON struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` +} + +type chatJSON struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` +} + +type messageJSON struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` +} + func (u User) MarshalJSON() ([]byte, error) { - type response struct { - ID string `json:"id"` - Username string `json:"username"` - DisplayName string `json:"display_name"` - CreatedAt string `json:"created_at"` - } - return json.Marshal(response{u.ID, u.Username, u.DisplayName, formatTime(u.CreatedAt)}) + return json.Marshal(userJSON{u.ID, u.Username, u.DisplayName, formatTime(u.CreatedAt)}) } func (c Chat) MarshalJSON() ([]byte, error) { - type response struct { - ID string `json:"id"` - Title string `json:"title"` - MemberIDs []string `json:"member_ids"` - CreatedAt string `json:"created_at"` - } - return json.Marshal(response{c.ID, c.Title, c.MemberIDs, formatTime(c.CreatedAt)}) + return json.Marshal(chatJSON{c.ID, c.Title, c.MemberIDs, formatTime(c.CreatedAt)}) } func (m Message) MarshalJSON() ([]byte, error) { - type response struct { - ID string `json:"id"` - ChatID string `json:"chat_id"` - SenderID string `json:"sender_id"` - Text string `json:"text"` - CreatedAt string `json:"created_at"` - } - return json.Marshal(response{m.ID, m.ChatID, m.SenderID, m.Text, formatTime(m.CreatedAt)}) + return json.Marshal(messageJSON{m.ID, m.ChatID, m.SenderID, m.Text, formatTime(m.CreatedAt)}) } func FormatTime(value time.Time) string { diff --git a/internal/password/password.go b/internal/password/password.go index e85b13e..5dd8b1b 100644 --- a/internal/password/password.go +++ b/internal/password/password.go @@ -6,95 +6,128 @@ import ( "encoding/base64" "errors" "fmt" + "strconv" "strings" "golang.org/x/crypto/argon2" ) -const ( - MemoryKiB uint32 = 64 * 1024 - Iterations uint32 = 3 - Parallelism uint8 = 2 - SaltLength = 16 - KeyLength uint32 = 32 +var ( + ErrInvalidConfig = errors.New("invalid password configuration") + ErrInvalidHash = errors.New("invalid password hash") ) -var ErrInvalidHash = errors.New("invalid password hash") - -var dummyHash = encode( - make([]byte, SaltLength), - argon2.IDKey([]byte("invalid-user-password"), make([]byte, SaltLength), Iterations, MemoryKiB, Parallelism, KeyLength), -) - -type Hasher struct{} - -func (Hasher) Hash(value string) (string, error) { - return Hash(value) +type Config struct { + MemoryKiB uint32 + Iterations uint32 + Parallelism uint8 + SaltLength uint32 + KeyLength uint32 } -func (Hasher) Verify(value, encodedHash string) (bool, error) { - return Verify(value, encodedHash) +type Hasher struct { + config Config + dummyHash string } -func (Hasher) DummyHash() string { - return dummyHash +func New(config Config) (*Hasher, error) { + if err := validateConfig(config); err != nil { + return nil, err + } + salt := make([]byte, config.SaltLength) + digest := argon2.IDKey([]byte("invalid-user-password"), salt, config.Iterations, config.MemoryKiB, config.Parallelism, config.KeyLength) + return &Hasher{config: config, dummyHash: encode(config, salt, digest)}, nil } -func Hash(value string) (string, error) { - salt := make([]byte, SaltLength) +func validateConfig(config Config) error { + if config.MemoryKiB < 8*1024 || config.MemoryKiB > 1024*1024 || + config.Iterations < 1 || config.Iterations > 20 || + config.Parallelism < 1 || + config.SaltLength < 8 || config.SaltLength > 1024 || + config.KeyLength < 16 || config.KeyLength > 1024 { + return ErrInvalidConfig + } + return nil +} + +func (h *Hasher) Hash(value string) (string, error) { + salt := make([]byte, h.config.SaltLength) if _, err := rand.Read(salt); err != nil { return "", fmt.Errorf("generate password salt: %w", err) } - - digest := argon2.IDKey([]byte(value), salt, Iterations, MemoryKiB, Parallelism, KeyLength) - - return encode(salt, digest), nil + digest := argon2.IDKey([]byte(value), salt, h.config.Iterations, h.config.MemoryKiB, h.config.Parallelism, h.config.KeyLength) + return encode(h.config, salt, digest), nil } -func encode(salt, digest []byte) string { +func (h *Hasher) Verify(value, encodedHash string) (bool, error) { + config, salt, digest, err := decode(encodedHash) + if err != nil { + return false, err + } + actual := argon2.IDKey([]byte(value), salt, config.Iterations, config.MemoryKiB, config.Parallelism, config.KeyLength) + return subtle.ConstantTimeCompare(actual, digest) == 1, nil +} + +func (h *Hasher) DummyHash() string { + return h.dummyHash +} + +func encode(config Config, salt, digest []byte) string { return fmt.Sprintf( "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", argon2.Version, - MemoryKiB, - Iterations, - Parallelism, + config.MemoryKiB, + config.Iterations, + config.Parallelism, base64.RawStdEncoding.EncodeToString(salt), base64.RawStdEncoding.EncodeToString(digest), ) } -func Verify(value, encodedHash string) (bool, error) { - salt, digest, err := decode(encodedHash) - if err != nil { - return false, err - } - - actual := argon2.IDKey([]byte(value), salt, Iterations, MemoryKiB, Parallelism, KeyLength) - return subtle.ConstantTimeCompare(actual, digest) == 1, nil -} - -func decode(encodedHash string) ([]byte, []byte, error) { +func decode(encodedHash string) (Config, []byte, []byte, error) { parts := strings.Split(encodedHash, "$") - if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" { - return nil, nil, ErrInvalidHash + if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" || parts[2] != fmt.Sprintf("v=%d", argon2.Version) { + return Config{}, nil, nil, ErrInvalidHash } - if parts[2] != fmt.Sprintf("v=%d", argon2.Version) { - return nil, nil, ErrInvalidHash + parameters := strings.Split(parts[3], ",") + if len(parameters) != 3 { + return Config{}, nil, nil, ErrInvalidHash } - if parts[3] != fmt.Sprintf("m=%d,t=%d,p=%d", MemoryKiB, Iterations, Parallelism) { - return nil, nil, ErrInvalidHash + memory, err := parameter(parameters[0], "m=", 32) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + iterations, err := parameter(parameters[1], "t=", 32) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + parallelism, err := parameter(parameters[2], "p=", 8) + if err != nil { + return Config{}, nil, nil, ErrInvalidHash } salt, err := base64.RawStdEncoding.Strict().DecodeString(parts[4]) - if err != nil || len(salt) != SaltLength { - return nil, nil, ErrInvalidHash + if err != nil { + return Config{}, nil, nil, ErrInvalidHash } - digest, err := base64.RawStdEncoding.Strict().DecodeString(parts[5]) - if err != nil || len(digest) != int(KeyLength) { - return nil, nil, ErrInvalidHash + if err != nil { + return Config{}, nil, nil, ErrInvalidHash } + config := Config{ + MemoryKiB: uint32(memory), Iterations: uint32(iterations), Parallelism: uint8(parallelism), + SaltLength: uint32(len(salt)), KeyLength: uint32(len(digest)), + } + if err := validateConfig(config); err != nil { + return Config{}, nil, nil, ErrInvalidHash + } + return config, salt, digest, nil +} - return salt, digest, nil +func parameter(value, prefix string, bitSize int) (uint64, error) { + if !strings.HasPrefix(value, prefix) { + return 0, ErrInvalidHash + } + return strconv.ParseUint(strings.TrimPrefix(value, prefix), 10, bitSize) } diff --git a/internal/password/password_test.go b/internal/password/password_test.go index f52aa08..df25f40 100644 --- a/internal/password/password_test.go +++ b/internal/password/password_test.go @@ -3,7 +3,10 @@ package password import "testing" func TestHasher(t *testing.T) { - hasher := Hasher{} + hasher, err := New(testConfig()) + if err != nil { + t.Fatalf("New() error = %v", err) + } hash, err := hasher.Hash("T3st-password-123") if err != nil { t.Fatalf("Hash() error = %v", err) @@ -27,7 +30,15 @@ func TestHasher(t *testing.T) { } func TestVerifyRejectsMalformedHash(t *testing.T) { - if _, err := (Hasher{}).Verify("password", "invalid"); err == nil { + hasher, err := New(testConfig()) + if err != nil { + t.Fatalf("New() error = %v", err) + } + if _, err := hasher.Verify("password", "invalid"); err == nil { t.Fatal("Verify() error = nil for malformed hash") } } + +func testConfig() Config { + return Config{MemoryKiB: 8 * 1024, Iterations: 1, Parallelism: 1, SaltLength: 16, KeyLength: 32} +} diff --git a/lab2.env.example b/lab2.env.example index 7576a38..5dd636b 100644 --- a/lab2.env.example +++ b/lab2.env.example @@ -1,18 +1,61 @@ +# Адрес и внутренний порт HTTP-сервера. APP_HOST=0.0.0.0 APP_PORT=8080 + +# Адреса публикации сервисов на локальной машине. +API_BIND_ADDRESS=127.0.0.1:8080 +SWAGGER_BIND_ADDRESS=127.0.0.1:8081 +PROMETHEUS_BIND_ADDRESS=127.0.0.1:9090 +GRAFANA_BIND_ADDRESS=127.0.0.1:3000 + +# Время жизни сессии и используемое хранилище. SESSION_TTL_SECONDS=3600 SESSION_STORE=valkey -DB_MIN_CONNS=1 -DB_MAX_CONNS=10 -DEPENDENCY_TIMEOUT_SECONDS=5 -SWAGGER_PORT=8081 + +# Учётные данные локального PostgreSQL и строка подключения API. POSTGRES_USER=messenger POSTGRES_DB=messenger +POSTGRES_PASSWORD=local-postgres-password +DATABASE_URL=postgres://messenger:local-postgres-password@postgres:5432/messenger?sslmode=disable + +# Пароль локального Valkey и строка подключения API. +VALKEY_PASSWORD=local-valkey-password +CACHE_URL=redis://default:local-valkey-password@valkey:6379/0 + +# Размер пула и обслуживание соединений PostgreSQL. +DB_MIN_CONNS=1 +DB_MAX_CONNS=10 +DB_MAX_CONNECTION_AGE_SECONDS=1800 +DB_MAX_CONNECTION_IDLE_SECONDS=300 +DB_HEALTH_CHECK_SECONDS=30 + +# Таймауты зависимостей, миграций и HTTP-запросов. +DEPENDENCY_TIMEOUT_SECONDS=5 +MIGRATION_TIMEOUT_SECONDS=30 +REQUEST_TIMEOUT_SECONDS=5 +HTTP_READ_HEADER_TIMEOUT_SECONDS=5 +HTTP_READ_TIMEOUT_SECONDS=10 +HTTP_WRITE_TIMEOUT_SECONDS=10 +HTTP_IDLE_TIMEOUT_SECONDS=60 +HTTP_SHUTDOWN_TIMEOUT_SECONDS=10 + +# Параметры Argon2id для новых хешей паролей. +PASSWORD_MEMORY_KIB=65536 +PASSWORD_ITERATIONS=3 +PASSWORD_PARALLELISM=2 +PASSWORD_SALT_LENGTH=16 +PASSWORD_KEY_LENGTH=32 + +# Порт Swagger внутри конфигурации CORS API. +SWAGGER_PORT=8081 + +# Ограничения ресурсов контейнеров приложения и хранилищ. API_CPUS=2 API_MEMORY=512m POSTGRES_CPUS=2 POSTGRES_MEMORY=1g VALKEY_CPUS=1 VALKEY_MEMORY=256m -PROMETHEUS_PORT=9090 -GRAFANA_PORT=3000 + +# Пароль локального администратора Grafana. +GRAFANA_ADMIN_PASSWORD=local-grafana-password diff --git a/monitoring/grafana/provisioning/dashboards/messenger.yml b/monitoring/grafana/provisioning/dashboards/messenger.yml index e950d2c..fa7934c 100644 --- a/monitoring/grafana/provisioning/dashboards/messenger.yml +++ b/monitoring/grafana/provisioning/dashboards/messenger.yml @@ -7,4 +7,4 @@ providers: disableDeletion: true editable: false options: - path: /var/lib/grafana/dashboards + path: /etc/grafana/dashboards diff --git a/scripts/backup-restore.sh b/scripts/backup-restore.sh index a15e8ba..47c0aad 100755 --- a/scripts/backup-restore.sh +++ b/scripts/backup-restore.sh @@ -8,23 +8,23 @@ trap 'rm -f "$backup_file"' EXIT started_at=$(date +%s) docker compose exec -T postgres sh -eu -c ' - export PGPASSWORD="$(cat /run/secrets/postgres_password)" + export PGPASSWORD="$POSTGRES_PASSWORD" pg_dump --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" --format custom ' > "$backup_file" docker compose exec -T postgres sh -eu -c ' - export PGPASSWORD="$(cat /run/secrets/postgres_password)" + export PGPASSWORD="$POSTGRES_PASSWORD" dropdb --username "$POSTGRES_USER" --if-exists "$1" createdb --username "$POSTGRES_USER" "$1" ' sh "$restore_database" docker compose exec -T postgres sh -eu -c ' - export PGPASSWORD="$(cat /run/secrets/postgres_password)" + export PGPASSWORD="$POSTGRES_PASSWORD" pg_restore --username "$POSTGRES_USER" --dbname "$1" --no-owner --no-privileges ' sh "$restore_database" < "$backup_file" original=$(docker compose exec -T postgres sh -eu -c ' - export PGPASSWORD="$(cat /run/secrets/postgres_password)" + export PGPASSWORD="$POSTGRES_PASSWORD" psql --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" --tuples-only --no-align --command " SELECT count(*) FROM users; SELECT count(*) FROM chats; @@ -43,7 +43,7 @@ original=$(docker compose exec -T postgres sh -eu -c ' ') restored=$(docker compose exec -T postgres sh -eu -c ' - export PGPASSWORD="$(cat /run/secrets/postgres_password)" + export PGPASSWORD="$POSTGRES_PASSWORD" psql --username "$POSTGRES_USER" --dbname "$1" --tuples-only --no-align --command " SELECT count(*) FROM users; SELECT count(*) FROM chats; diff --git a/scripts/init-local-secrets.sh b/scripts/init-local-secrets.sh deleted file mode 100755 index 5f3783c..0000000 --- a/scripts/init-local-secrets.sh +++ /dev/null @@ -1,21 +0,0 @@ -#!/bin/sh - -set -eu - -if [ -e secrets/postgres_password ] || [ -e secrets/valkey_password ] || [ -e secrets/database_url ] || [ -e secrets/cache_url ] || [ -e secrets/grafana_admin_password ]; then - echo "secrets already exist" >&2 - exit 1 -fi - -umask 077 -mkdir -p secrets - -postgres_password=$(openssl rand -hex 24) -valkey_password=$(openssl rand -hex 24) -grafana_admin_password=$(openssl rand -hex 24) - -printf '%s' "$postgres_password" > secrets/postgres_password -printf '%s' "$valkey_password" > secrets/valkey_password -printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$postgres_password" > secrets/database_url -printf 'redis://default:%s@valkey:6379/0' "$valkey_password" > secrets/cache_url -printf '%s' "$grafana_admin_password" > secrets/grafana_admin_password -- 2.54.0