From 380d0ef71000d0e05edb27711fbf841b79e10a85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Wed, 30 Sep 2026 22:32:04 +0300 Subject: [PATCH 01/61] feat: port backend implementation from lab1 --- .dockerignore | 22 ++++ Dockerfile | 29 +++++ backend/cmd/server/main.go | 69 +++++++++++ backend/go.mod | 40 +++++++ backend/go.sum | 91 ++++++++++++++ backend/internal/domain/entity.go | 29 +++++ backend/internal/domain/errors.go | 82 +++++++++++++ backend/internal/domain/repository.go | 20 ++++ backend/internal/httpapi/dto/chat.go | 39 ++++++ backend/internal/httpapi/dto/error.go | 69 +++++++++++ backend/internal/httpapi/dto/health.go | 5 + backend/internal/httpapi/dto/message.go | 40 +++++++ backend/internal/httpapi/dto/user.go | 28 +++++ backend/internal/httpapi/handler/bind.go | 52 ++++++++ backend/internal/httpapi/handler/chat.go | 88 ++++++++++++++ backend/internal/httpapi/handler/health.go | 23 ++++ backend/internal/httpapi/handler/message.go | 68 +++++++++++ backend/internal/httpapi/handler/response.go | 35 ++++++ backend/internal/httpapi/handler/user.go | 43 +++++++ backend/internal/httpapi/middleware/auth.go | 49 ++++++++ .../internal/httpapi/middleware/requestid.go | 32 +++++ backend/internal/httpapi/router.go | 45 +++++++ backend/internal/service/chat.go | 95 +++++++++++++++ backend/internal/service/message.go | 72 +++++++++++ backend/internal/service/user.go | 76 ++++++++++++ backend/internal/storage/memory/chat.go | 102 ++++++++++++++++ backend/internal/storage/memory/cursor.go | 47 ++++++++ backend/internal/storage/memory/message.go | 93 +++++++++++++++ backend/internal/storage/memory/storage.go | 34 ++++++ backend/internal/storage/memory/user.go | 59 +++++++++ student-tests/README.md | 7 ++ student-tests/run_all.py | 20 ++++ student-tests/test_cases.py | 112 ++++++++++++++++++ student-tests/test_concurrency.py | 80 +++++++++++++ 34 files changed, 1795 insertions(+) create mode 100644 Dockerfile create mode 100644 backend/cmd/server/main.go create mode 100644 backend/go.mod create mode 100644 backend/go.sum create mode 100644 backend/internal/domain/entity.go create mode 100644 backend/internal/domain/errors.go create mode 100644 backend/internal/domain/repository.go create mode 100644 backend/internal/httpapi/dto/chat.go create mode 100644 backend/internal/httpapi/dto/error.go create mode 100644 backend/internal/httpapi/dto/health.go create mode 100644 backend/internal/httpapi/dto/message.go create mode 100644 backend/internal/httpapi/dto/user.go create mode 100644 backend/internal/httpapi/handler/bind.go create mode 100644 backend/internal/httpapi/handler/chat.go create mode 100644 backend/internal/httpapi/handler/health.go create mode 100644 backend/internal/httpapi/handler/message.go create mode 100644 backend/internal/httpapi/handler/response.go create mode 100644 backend/internal/httpapi/handler/user.go create mode 100644 backend/internal/httpapi/middleware/auth.go create mode 100644 backend/internal/httpapi/middleware/requestid.go create mode 100644 backend/internal/httpapi/router.go create mode 100644 backend/internal/service/chat.go create mode 100644 backend/internal/service/message.go create mode 100644 backend/internal/service/user.go create mode 100644 backend/internal/storage/memory/chat.go create mode 100644 backend/internal/storage/memory/cursor.go create mode 100644 backend/internal/storage/memory/message.go create mode 100644 backend/internal/storage/memory/storage.go create mode 100644 backend/internal/storage/memory/user.go create mode 100644 student-tests/README.md create mode 100644 student-tests/run_all.py create mode 100644 student-tests/test_cases.py create mode 100644 student-tests/test_concurrency.py diff --git a/.dockerignore b/.dockerignore index bc16e556..9caa9493 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,5 +1,7 @@ .git +.gitignore .github + .env .env.* !.env.example @@ -13,8 +15,28 @@ backups *.p12 *.pfx *.jks + .venv __pycache__ node_modules + evidence .DS_Store + +tests +my-tests +scripts +examples +contracts +README.md +COURSE.md +CONTRIBUTING.md +MAINTAINERS.md +REPORT.md + +Makefile +requirements-dev.txt +Dockerfile.example + +Dockerfile +.dockerignore \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..16229253 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM golang:1.26.1-alpine AS builder + +WORKDIR /src + +COPY backend/go.mod backend/go.sum ./ +RUN go mod download + +COPY backend/ . + +RUN CGO_ENABLED=0 GOOS=linux go build \ + -trimpath \ + -ldflags="-s -w" \ + -o /out/server \ + ./cmd/server + +FROM alpine:3.20 + +RUN adduser -D -u 1000 app + +COPY --from=builder /out/server /server + +EXPOSE 8080 + +USER app + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD wget -q -O - http://127.0.0.1:8080/health/live >/dev/null || exit 1 + +ENTRYPOINT ["/server"] \ No newline at end of file diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go new file mode 100644 index 00000000..4ca897a6 --- /dev/null +++ b/backend/cmd/server/main.go @@ -0,0 +1,69 @@ +package main + +import ( + "context" + "errors" + "log" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "high-loud-apps-labs/internal/httpapi" + "high-loud-apps-labs/internal/httpapi/handler" + "high-loud-apps-labs/internal/httpapi/middleware" + "high-loud-apps-labs/internal/service" + "high-loud-apps-labs/internal/storage/memory" +) + +func main() { + addr := getenv("APP_HOST", "0.0.0.0") + ":" + getenv("APP_PORT", "8080") + + store := memory.New() + + userSvc := service.NewUserService(store.Users()) + chatSvc := service.NewChatService(store.Chats(), store.Users()) + messageSvc := service.NewMessageService(store.Messages(), store.Chats()) + + router := httpapi.NewRouter( + httpapi.Handlers{ + Health: handler.NewHealthHandler(), + User: handler.NewUserHandler(userSvc), + Chat: handler.NewChatHandler(chatSvc), + Message: handler.NewMessageHandler(messageSvc), + }, + middleware.Auth(store.Users()), + ) + + srv := &http.Server{ + Addr: addr, + Handler: router, + } + + go func() { + log.Printf("Запускаем на %s", addr) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Fatalf("Ошибка запуска: %v", err) + } + }() + + quit := make(chan os.Signal, 1) + signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) + <-quit + log.Println("Получен сигнал завершения, останавливаем сервер...") + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if err := srv.Shutdown(ctx); err != nil { + log.Fatalf("Ошибка при остановке: %v", err) + } + log.Println("Сервер остановлен") +} + +func getenv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} diff --git a/backend/go.mod b/backend/go.mod new file mode 100644 index 00000000..c2e4b21e --- /dev/null +++ b/backend/go.mod @@ -0,0 +1,40 @@ +module high-loud-apps-labs + +go 1.26.1 + +require ( + github.com/gin-gonic/gin v1.12.0 + github.com/google/uuid v1.6.0 +) + +require ( + github.com/bytedance/gopkg v0.1.3 // indirect + github.com/bytedance/sonic v1.15.0 // indirect + github.com/bytedance/sonic/loader v0.5.0 // indirect + github.com/cloudwego/base64x v0.1.6 // indirect + github.com/gabriel-vasile/mimetype v1.4.12 // indirect + github.com/gin-contrib/sse v1.1.0 // indirect + github.com/go-playground/locales v0.14.1 // indirect + github.com/go-playground/universal-translator v0.18.1 // indirect + github.com/go-playground/validator/v10 v10.30.1 // indirect + github.com/goccy/go-json v0.10.5 // indirect + github.com/goccy/go-yaml v1.19.2 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/cpuid/v2 v2.3.0 // indirect + github.com/leodido/go-urn v1.4.0 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/pelletier/go-toml/v2 v2.2.4 // indirect + github.com/quic-go/qpack v0.6.0 // indirect + github.com/quic-go/quic-go v0.59.0 // indirect + github.com/twitchyliquid64/golang-asm v0.15.1 // indirect + github.com/ugorji/go/codec v1.3.1 // indirect + go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect + golang.org/x/arch v0.22.0 // indirect + golang.org/x/crypto v0.48.0 // indirect + golang.org/x/net v0.51.0 // indirect + golang.org/x/sys v0.41.0 // indirect + golang.org/x/text v0.34.0 // indirect + google.golang.org/protobuf v1.36.10 // indirect +) diff --git a/backend/go.sum b/backend/go.sum new file mode 100644 index 00000000..0b62b839 --- /dev/null +++ b/backend/go.sum @@ -0,0 +1,91 @@ +github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M= +github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM= +github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE= +github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k= +github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE= +github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo= +github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= +github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= +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/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw= +github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= +github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w= +github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM= +github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8= +github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= +github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w= +github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM= +github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= +github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM= +github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= +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/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +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/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= +github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= +github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +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/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= +github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII= +github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw= +github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +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/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= +github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= +github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY= +github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4= +go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE= +go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI= +golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= +golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts= +golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos= +golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo= +golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= +golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk= +golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +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/backend/internal/domain/entity.go b/backend/internal/domain/entity.go new file mode 100644 index 00000000..ee00b9cd --- /dev/null +++ b/backend/internal/domain/entity.go @@ -0,0 +1,29 @@ +package domain + +import "time" + +type Health struct { + Status string +} + +type User struct { + ID string + Username string + DisplayName string + CreatedAt time.Time +} + +type Chat struct { + ID string + Title string + MemberIDs []string + CreatedAt time.Time +} + +type Message struct { + ID string + ChatID string + SenderID string + Text string + CreatedAt time.Time +} diff --git a/backend/internal/domain/errors.go b/backend/internal/domain/errors.go new file mode 100644 index 00000000..79f8a794 --- /dev/null +++ b/backend/internal/domain/errors.go @@ -0,0 +1,82 @@ +package domain + +import ( + "errors" + "fmt" +) + +type ErrorCode string + +const ( + CodeInvalidRequest ErrorCode = "invalid_request" + CodeUnauthorized ErrorCode = "unauthorized" + CodeNotFound ErrorCode = "not_found" + CodeConflict ErrorCode = "conflict" + CodeUnsupportedMediaType ErrorCode = "unsupported_media_type" + CodeInternalError ErrorCode = "internal_error" +) + +var ( + ErrNotFound = errors.New("не найдено") + ErrAlreadyExists = errors.New("уже существует") + ErrInvalidInput = errors.New("некорректные данные") + ErrForbidden = errors.New("доступ запрещён") + ErrUnsupportedMediaType = errors.New("неподдерживаемый тип содержимого") +) + +type NotFoundError struct { + Entity string + ID string +} + +func (e *NotFoundError) Error() string { + return fmt.Sprintf("%s с id %q не найден", e.Entity, e.ID) +} +func (e *NotFoundError) Unwrap() error { return ErrNotFound } +func (e *NotFoundError) Code() ErrorCode { return CodeNotFound } + +type AlreadyExistsError struct { + Entity string + Field string + Value string +} + +func (e *AlreadyExistsError) Error() string { + return fmt.Sprintf("%s с %s %q уже существует", e.Entity, e.Field, e.Value) +} +func (e *AlreadyExistsError) Unwrap() error { return ErrAlreadyExists } +func (e *AlreadyExistsError) Code() ErrorCode { return CodeConflict } + +type ValidationError struct { + Field string + Message string +} + +func (e *ValidationError) Error() string { + return fmt.Sprintf("ошибка валидации поля %q: %s", e.Field, e.Message) +} +func (e *ValidationError) Unwrap() error { return ErrInvalidInput } +func (e *ValidationError) Code() ErrorCode { return CodeInvalidRequest } + +type ForbiddenError struct { + Reason string +} + +func (e *ForbiddenError) Error() string { + return fmt.Sprintf("доступ запрещён: %s", e.Reason) +} +func (e *ForbiddenError) Unwrap() error { return ErrForbidden } +func (e *ForbiddenError) Code() ErrorCode { return CodeUnauthorized } + +type UnsupportedMediaTypeError struct { + MediaType string +} + +func (e *UnsupportedMediaTypeError) Error() string { + if e.MediaType == "" { + return "требуется Content-Type: application/json" + } + return fmt.Sprintf("неподдерживаемый Content-Type %q; требуется application/json", e.MediaType) +} +func (e *UnsupportedMediaTypeError) Unwrap() error { return ErrUnsupportedMediaType } +func (e *UnsupportedMediaTypeError) Code() ErrorCode { return CodeUnsupportedMediaType } diff --git a/backend/internal/domain/repository.go b/backend/internal/domain/repository.go new file mode 100644 index 00000000..02d344d9 --- /dev/null +++ b/backend/internal/domain/repository.go @@ -0,0 +1,20 @@ +package domain + +import "context" + +type UserRepository interface { + Create(ctx context.Context, user *User) error + GetByID(ctx context.Context, id string) (*User, error) + GetByUsername(ctx context.Context, username string) (*User, error) +} + +type ChatRepository interface { + Create(ctx context.Context, chat *Chat) error + GetByID(ctx context.Context, id string) (*Chat, error) + ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]Chat, *string, error) +} + +type MessageRepository interface { + Create(ctx context.Context, message *Message) error + ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]Message, *string, error) +} diff --git a/backend/internal/httpapi/dto/chat.go b/backend/internal/httpapi/dto/chat.go new file mode 100644 index 00000000..a9bf0425 --- /dev/null +++ b/backend/internal/httpapi/dto/chat.go @@ -0,0 +1,39 @@ +package dto + +import ( + "high-loud-apps-labs/internal/domain" +) + +type CreateChatRequest struct { + Title string `json:"title" binding:"required,min=1,max=100"` + MemberIDs []string `json:"member_ids" binding:"required,min=1,max=100,dive,uuid"` +} + +type ChatResponse struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` +} + +type ChatPageResponse struct { + Items []ChatResponse `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +func ChatFromDomain(c *domain.Chat) ChatResponse { + return ChatResponse{ + ID: c.ID, + Title: c.Title, + MemberIDs: append([]string(nil), c.MemberIDs...), + CreatedAt: c.CreatedAt.UTC().Format(timeFormat), + } +} + +func ChatsFromDomain(items []domain.Chat) []ChatResponse { + out := make([]ChatResponse, len(items)) + for i := range items { + out[i] = ChatFromDomain(&items[i]) + } + return out +} diff --git a/backend/internal/httpapi/dto/error.go b/backend/internal/httpapi/dto/error.go new file mode 100644 index 00000000..0fe6c002 --- /dev/null +++ b/backend/internal/httpapi/dto/error.go @@ -0,0 +1,69 @@ +package dto + +import ( + "errors" + + "high-loud-apps-labs/internal/domain" +) + +// делаем вложенный ответ через вкладку ErrorBody в обертку. + +type ErrorBody struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +type ErrorResponse struct { + Error ErrorBody `json:"error"` +} + +type coded interface { + Code() domain.ErrorCode +} + +func ErrorFromDomain(err error, requestID string) ErrorResponse { + var c coded + if errors.As(err, &c) { + return ErrorResponse{Error: ErrorBody{ + Code: string(c.Code()), + Message: err.Error(), + RequestID: requestID, + }} + } + code := domain.CodeInternalError + switch { + case errors.Is(err, domain.ErrNotFound): + code = domain.CodeNotFound + case errors.Is(err, domain.ErrAlreadyExists): + code = domain.CodeConflict + case errors.Is(err, domain.ErrInvalidInput): + code = domain.CodeInvalidRequest + case errors.Is(err, domain.ErrForbidden): + code = domain.CodeUnauthorized + case errors.Is(err, domain.ErrUnsupportedMediaType): + code = domain.CodeUnsupportedMediaType + } + return ErrorResponse{Error: ErrorBody{ + Code: string(code), + Message: err.Error(), + RequestID: requestID, + }} +} + +func StatusFromError(err error) int { + switch { + case errors.Is(err, domain.ErrNotFound): + return 404 + case errors.Is(err, domain.ErrAlreadyExists): + return 409 + case errors.Is(err, domain.ErrInvalidInput): + return 400 + case errors.Is(err, domain.ErrForbidden): + return 401 + case errors.Is(err, domain.ErrUnsupportedMediaType): + return 415 + default: + return 500 + } +} diff --git a/backend/internal/httpapi/dto/health.go b/backend/internal/httpapi/dto/health.go new file mode 100644 index 00000000..8bb35034 --- /dev/null +++ b/backend/internal/httpapi/dto/health.go @@ -0,0 +1,5 @@ +package dto + +type HealthResponse struct { + Status string `json:"status"` +} diff --git a/backend/internal/httpapi/dto/message.go b/backend/internal/httpapi/dto/message.go new file mode 100644 index 00000000..31f9471d --- /dev/null +++ b/backend/internal/httpapi/dto/message.go @@ -0,0 +1,40 @@ +package dto + +import ( + "high-loud-apps-labs/internal/domain" +) + +type CreateMessageRequest struct { + Text string `json:"text" binding:"required,min=1,max=4000"` +} + +type MessageResponse struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` +} + +type MessagePageResponse struct { + Items []MessageResponse `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +func MessageFromDomain(m *domain.Message) MessageResponse { + return MessageResponse{ + ID: m.ID, + ChatID: m.ChatID, + SenderID: m.SenderID, + Text: m.Text, + CreatedAt: m.CreatedAt.UTC().Format(timeFormat), + } +} + +func MessagesFromDomain(items []domain.Message) []MessageResponse { + out := make([]MessageResponse, len(items)) + for i := range items { + out[i] = MessageFromDomain(&items[i]) + } + return out +} diff --git a/backend/internal/httpapi/dto/user.go b/backend/internal/httpapi/dto/user.go new file mode 100644 index 00000000..07b9ebf0 --- /dev/null +++ b/backend/internal/httpapi/dto/user.go @@ -0,0 +1,28 @@ +package dto + +import ( + "high-loud-apps-labs/internal/domain" +) + +const timeFormat = "2006-01-02T15:04:05.000000Z07:00" + +type CreateUserRequest struct { + Username string `json:"username" binding:"required,min=3,max=32"` + DisplayName string `json:"display_name" binding:"required,min=1,max=100"` +} + +type UserResponse struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` +} + +func UserFromDomain(u *domain.User) UserResponse { + return UserResponse{ + ID: u.ID, + Username: u.Username, + DisplayName: u.DisplayName, + CreatedAt: u.CreatedAt.UTC().Format(timeFormat), + } +} diff --git a/backend/internal/httpapi/handler/bind.go b/backend/internal/httpapi/handler/bind.go new file mode 100644 index 00000000..cca73874 --- /dev/null +++ b/backend/internal/httpapi/handler/bind.go @@ -0,0 +1,52 @@ +package handler + +import ( + "bytes" + "encoding/json" + "errors" + "io" + "mime" + "strings" + + "github.com/gin-gonic/gin" + "github.com/gin-gonic/gin/binding" + + "high-loud-apps-labs/internal/domain" +) + +func bindStrictJSON(c *gin.Context, dst any) error { + ct := c.GetHeader("Content-Type") + mediaType, _, err := mime.ParseMediaType(ct) + if ct == "" || err != nil || !strings.EqualFold(mediaType, "application/json") { + return &domain.UnsupportedMediaTypeError{MediaType: ct} + } + + body, err := io.ReadAll(c.Request.Body) + if err != nil { + return &badRequestError{msg: "не удалось прочитать тело запроса"} + } + _ = c.Request.Body.Close() + + dec := json.NewDecoder(bytes.NewReader(body)) + dec.DisallowUnknownFields() + + if err := dec.Decode(dst); err != nil { + if errors.Is(err, io.EOF) { + return &badRequestError{msg: "тело запроса обязательно"} + } + return &badRequestError{msg: err.Error()} + } + + // Отклоняем любой непустой остаток после первого JSON-значения. + var extra json.RawMessage + if err := dec.Decode(&extra); !errors.Is(err, io.EOF) { + return &badRequestError{msg: "тело запроса содержит данные после JSON"} + } + + if v := binding.Validator; v != nil { + if err := v.ValidateStruct(dst); err != nil { + return &badRequestError{msg: err.Error()} + } + } + return nil +} diff --git a/backend/internal/httpapi/handler/chat.go b/backend/internal/httpapi/handler/chat.go new file mode 100644 index 00000000..86fc2cd0 --- /dev/null +++ b/backend/internal/httpapi/handler/chat.go @@ -0,0 +1,88 @@ +package handler + +import ( + "net/http" + "strconv" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/httpapi/middleware" + "high-loud-apps-labs/internal/service" +) + +type ChatHandler struct { + chats *service.ChatService +} + +func NewChatHandler(chats *service.ChatService) *ChatHandler { + return &ChatHandler{chats: chats} +} + +func (h *ChatHandler) Create(c *gin.Context) { + var req dto.CreateChatRequest + if err := bindStrictJSON(c, &req); err != nil { + respondError(c, err) + return + } + me := middleware.CurrentUser(c) + + chat, err := h.chats.Create(c.Request.Context(), me.ID, req.Title, req.MemberIDs) + if err != nil { + respondError(c, err) + return + } + c.JSON(http.StatusCreated, dto.ChatFromDomain(chat)) +} + +func (h *ChatHandler) Get(c *gin.Context) { + me := middleware.CurrentUser(c) + + chatID, err := parseUUIDPathParam(c, "chat_id") + if err != nil { + respondError(c, err) + return + } + + chat, err := h.chats.Get(c.Request.Context(), me.ID, chatID) + if err != nil { + respondError(c, err) + return + } + c.JSON(http.StatusOK, dto.ChatFromDomain(chat)) +} + +func (h *ChatHandler) List(c *gin.Context) { + me := middleware.CurrentUser(c) + limit, cursor, err := parseListQuery(c) + if err != nil { + respondError(c, err) + return + } + + items, next, err := h.chats.List(c.Request.Context(), me.ID, limit, cursor) + if err != nil { + respondError(c, err) + return + } + c.JSON(http.StatusOK, dto.ChatPageResponse{ + Items: dto.ChatsFromDomain(items), + NextCursor: next, + }) +} + +func parseListQuery(c *gin.Context) (int, *string, error) { + limit := 50 + if v := c.Query("limit"); v != "" { + n, err := strconv.Atoi(v) + if err != nil || n < 1 || n > 100 { + return 0, nil, &badRequestError{msg: "limit должен быть целым 1..100"} + } + limit = n + } + var cursor *string + if v := c.Query("cursor"); v != "" { + cursor = &v + } + return limit, cursor, nil +} diff --git a/backend/internal/httpapi/handler/health.go b/backend/internal/httpapi/handler/health.go new file mode 100644 index 00000000..fc4ee1ea --- /dev/null +++ b/backend/internal/httpapi/handler/health.go @@ -0,0 +1,23 @@ +package handler + +import ( + "net/http" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/httpapi/dto" +) + +type HealthHandler struct{} + +func NewHealthHandler() *HealthHandler { + return &HealthHandler{} +} + +func (h *HealthHandler) Live(c *gin.Context) { + c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"}) +} + +func (h *HealthHandler) Ready(c *gin.Context) { + c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"}) +} diff --git a/backend/internal/httpapi/handler/message.go b/backend/internal/httpapi/handler/message.go new file mode 100644 index 00000000..354c7ed7 --- /dev/null +++ b/backend/internal/httpapi/handler/message.go @@ -0,0 +1,68 @@ +package handler + +import ( + "net/http" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/httpapi/middleware" + "high-loud-apps-labs/internal/service" +) + +type MessageHandler struct { + messages *service.MessageService +} + +func NewMessageHandler(messages *service.MessageService) *MessageHandler { + return &MessageHandler{messages: messages} +} + +func (h *MessageHandler) Create(c *gin.Context) { + var req dto.CreateMessageRequest + if err := bindStrictJSON(c, &req); err != nil { + respondError(c, err) + return + } + + me := middleware.CurrentUser(c) + + chatID, err := parseUUIDPathParam(c, "chat_id") + if err != nil { + respondError(c, err) + return + } + + m, err := h.messages.Create(c.Request.Context(), me.ID, chatID, req.Text) + if err != nil { + respondError(c, err) + return + } + c.JSON(http.StatusCreated, dto.MessageFromDomain(m)) +} + +func (h *MessageHandler) List(c *gin.Context) { + me := middleware.CurrentUser(c) + + chatID, err := parseUUIDPathParam(c, "chat_id") + if err != nil { + respondError(c, err) + return + } + + limit, cursor, err := parseListQuery(c) + if err != nil { + respondError(c, err) + return + } + + items, next, err := h.messages.List(c.Request.Context(), me.ID, chatID, limit, cursor) + if err != nil { + respondError(c, err) + return + } + c.JSON(http.StatusOK, dto.MessagePageResponse{ + Items: dto.MessagesFromDomain(items), + NextCursor: next, + }) +} diff --git a/backend/internal/httpapi/handler/response.go b/backend/internal/httpapi/handler/response.go new file mode 100644 index 00000000..5f066097 --- /dev/null +++ b/backend/internal/httpapi/handler/response.go @@ -0,0 +1,35 @@ +package handler + +import ( + "github.com/gin-gonic/gin" + "github.com/google/uuid" + + "high-loud-apps-labs/internal/domain" + "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/httpapi/middleware" +) + +type badRequestError struct{ msg string } + +func (e *badRequestError) Error() string { return e.msg } +func (e *badRequestError) Unwrap() error { return domain.ErrInvalidInput } +func (e *badRequestError) Code() domain.ErrorCode { return domain.CodeInvalidRequest } + +func parseUUIDPathParam(c *gin.Context, name string) (string, error) { + raw := c.Param(name) + if raw == "" { + return "", &badRequestError{msg: "параметр " + name + " обязателен"} + } + + id, err := uuid.Parse(raw) + if err != nil { + return "", &badRequestError{msg: "параметр " + name + " должен быть корректным UUID"} + } + + return id.String(), nil +} + +func respondError(c *gin.Context, err error) { + reqID := middleware.GetRequestID(c) + c.JSON(dto.StatusFromError(err), dto.ErrorFromDomain(err, reqID)) +} diff --git a/backend/internal/httpapi/handler/user.go b/backend/internal/httpapi/handler/user.go new file mode 100644 index 00000000..35ad917a --- /dev/null +++ b/backend/internal/httpapi/handler/user.go @@ -0,0 +1,43 @@ +package handler + +import ( + "net/http" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/httpapi/middleware" + "high-loud-apps-labs/internal/service" +) + +type UserHandler struct { + users *service.UserService +} + +func NewUserHandler(users *service.UserService) *UserHandler { + return &UserHandler{users: users} +} + +func (h *UserHandler) Create(c *gin.Context) { + var req dto.CreateUserRequest + if err := bindStrictJSON(c, &req); err != nil { + respondError(c, err) + return + } + + u, err := h.users.Create(c.Request.Context(), req.Username, req.DisplayName) + if err != nil { + respondError(c, err) + return + } + c.JSON(http.StatusCreated, dto.UserFromDomain(u)) +} + +func (h *UserHandler) Current(c *gin.Context) { + u := middleware.CurrentUser(c) + if u == nil { + respondError(c, &badRequestError{msg: "нет текущего пользователя"}) + return + } + c.JSON(http.StatusOK, dto.UserFromDomain(u)) +} diff --git a/backend/internal/httpapi/middleware/auth.go b/backend/internal/httpapi/middleware/auth.go new file mode 100644 index 00000000..589287fa --- /dev/null +++ b/backend/internal/httpapi/middleware/auth.go @@ -0,0 +1,49 @@ +package middleware + +import ( + "net/http" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/domain" + "high-loud-apps-labs/internal/httpapi/dto" +) + +const CurrentUserKey = "current_user" + +func Auth(users domain.UserRepository) gin.HandlerFunc { + return func(c *gin.Context) { + id := c.GetHeader("X-User-Id") + if id == "" { + abortUnauthorized(c, "требуется X-User-Id") + return + } + + u, err := users.GetByID(c.Request.Context(), id) + if err != nil { + abortUnauthorized(c, "неизвестный пользователь") + return + } + + c.Set(CurrentUserKey, u) + c.Next() + } +} + +func CurrentUser(c *gin.Context) *domain.User { + if v, ok := c.Get(CurrentUserKey); ok { + if u, ok := v.(*domain.User); ok { + return u + } + } + return nil +} + +func abortUnauthorized(c *gin.Context, msg string) { + reqID := GetRequestID(c) + body := dto.ErrorFromDomain( + &domain.ForbiddenError{Reason: msg}, + reqID, + ) + c.AbortWithStatusJSON(http.StatusUnauthorized, body) +} diff --git a/backend/internal/httpapi/middleware/requestid.go b/backend/internal/httpapi/middleware/requestid.go new file mode 100644 index 00000000..43c90113 --- /dev/null +++ b/backend/internal/httpapi/middleware/requestid.go @@ -0,0 +1,32 @@ +package middleware + +import ( + "github.com/gin-gonic/gin" + "github.com/google/uuid" +) + +const ( + RequestIDKey = "request_id" + RequestIDHeader = "X-Request-Id" +) + +func RequestID() gin.HandlerFunc { + return func(c *gin.Context) { + id := c.GetHeader(RequestIDHeader) + if id == "" { + id = uuid.NewString() + } + c.Set(RequestIDKey, id) + c.Writer.Header().Set(RequestIDHeader, id) + c.Next() + } +} + +func GetRequestID(c *gin.Context) string { + if v, ok := c.Get(RequestIDKey); ok { + if s, ok := v.(string); ok { + return s + } + } + return "" +} diff --git a/backend/internal/httpapi/router.go b/backend/internal/httpapi/router.go new file mode 100644 index 00000000..48a78a76 --- /dev/null +++ b/backend/internal/httpapi/router.go @@ -0,0 +1,45 @@ +package httpapi + +import ( + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/httpapi/handler" + "high-loud-apps-labs/internal/httpapi/middleware" +) + +type Handlers struct { + Health *handler.HealthHandler + User *handler.UserHandler + Chat *handler.ChatHandler + Message *handler.MessageHandler +} + +func NewRouter(h Handlers, auth gin.HandlerFunc) *gin.Engine { + gin.EnableJsonDecoderDisallowUnknownFields() + + r := gin.New() + r.Use(gin.Logger()) + r.Use(gin.Recovery()) + r.Use(middleware.RequestID()) + + r.GET("/health/live", h.Health.Live) + r.GET("/health/ready", h.Health.Ready) + + api := r.Group("/api/v1") + { + api.POST("/users", h.User.Create) + } + + protected := api.Group("") + protected.Use(auth) + { + protected.GET("/users/me", h.User.Current) + protected.POST("/chats", h.Chat.Create) + protected.GET("/chats", h.Chat.List) + protected.GET("/chats/:chat_id", h.Chat.Get) + protected.POST("/chats/:chat_id/messages", h.Message.Create) + protected.GET("/chats/:chat_id/messages", h.Message.List) + } + + return r +} diff --git a/backend/internal/service/chat.go b/backend/internal/service/chat.go new file mode 100644 index 00000000..caa8dcec --- /dev/null +++ b/backend/internal/service/chat.go @@ -0,0 +1,95 @@ +package service + +import ( + "context" + "errors" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" + + "high-loud-apps-labs/internal/domain" +) + +type ChatService struct { + chats domain.ChatRepository + users domain.UserRepository +} + +func NewChatService(chats domain.ChatRepository, users domain.UserRepository) *ChatService { + return &ChatService{chats: chats, users: users} +} + +func (s *ChatService) Create(ctx context.Context, creatorID, title string, memberIDs []string) (*domain.Chat, error) { + if strings.TrimSpace(title) == "" { + return nil, &domain.ValidationError{ + Field: "title", + Message: "не может состоять только из пробелов", + } + } + if utf8.RuneCountInString(title) > 100 { + return nil, &domain.ValidationError{ + Field: "title", + Message: "не более 100 символов", + } + } + + seen := make(map[string]struct{}, len(memberIDs)) + for _, id := range memberIDs { + if _, dup := seen[id]; dup { + return nil, &domain.ValidationError{ + Field: "member_ids", + Message: "дубликаты запрещены", + } + } + seen[id] = struct{}{} + } + + if _, ok := seen[creatorID]; !ok { + return nil, &domain.ValidationError{ + Field: "member_ids", + Message: "создатель должен входить в список участников", + } + } + + for _, id := range memberIDs { + if _, err := s.users.GetByID(ctx, id); err != nil { + if errors.Is(err, domain.ErrNotFound) { + return nil, &domain.ValidationError{ + Field: "member_ids", + Message: "неизвестный участник " + id, + } + } + return nil, err + } + } + + c := &domain.Chat{ + ID: uuid.NewString(), + Title: title, + MemberIDs: append([]string(nil), memberIDs...), + CreatedAt: time.Now().UTC(), + } + if err := s.chats.Create(ctx, c); err != nil { + return nil, err + } + return c, nil +} + +func (s *ChatService) Get(ctx context.Context, userID, chatID string) (*domain.Chat, error) { + c, err := s.chats.GetByID(ctx, chatID) + if err != nil { + return nil, err + } + for _, m := range c.MemberIDs { + if m == userID { + return c, nil + } + } + return nil, &domain.NotFoundError{Entity: "chat", ID: chatID} +} + +func (s *ChatService) List(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) { + return s.chats.ListByMember(ctx, userID, limit, cursor) +} diff --git a/backend/internal/service/message.go b/backend/internal/service/message.go new file mode 100644 index 00000000..1814d962 --- /dev/null +++ b/backend/internal/service/message.go @@ -0,0 +1,72 @@ +package service + +import ( + "context" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" + + "high-loud-apps-labs/internal/domain" +) + +type MessageService struct { + messages domain.MessageRepository + chats domain.ChatRepository +} + +func NewMessageService(messages domain.MessageRepository, chats domain.ChatRepository) *MessageService { + return &MessageService{messages: messages, chats: chats} +} + +func (s *MessageService) Create(ctx context.Context, senderID, chatID, text string) (*domain.Message, error) { + if strings.TrimSpace(text) == "" { + return nil, &domain.ValidationError{ + Field: "text", + Message: "не может состоять только из пробелов", + } + } + if utf8.RuneCountInString(text) > 4000 { + return nil, &domain.ValidationError{ + Field: "text", + Message: "не более 4000 символов", + } + } + + if err := s.ensureMember(ctx, senderID, chatID); err != nil { + return nil, err + } + + m := &domain.Message{ + ID: uuid.NewString(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: time.Now().UTC(), + } + if err := s.messages.Create(ctx, m); err != nil { + return nil, err + } + return m, nil +} + +func (s *MessageService) List(ctx context.Context, userID, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) { + if err := s.ensureMember(ctx, userID, chatID); err != nil { + return nil, nil, err + } + return s.messages.ListByChat(ctx, chatID, limit, cursor) +} + +func (s *MessageService) ensureMember(ctx context.Context, userID, chatID string) error { + c, err := s.chats.GetByID(ctx, chatID) + if err != nil { + return err + } + for _, m := range c.MemberIDs { + if m == userID { + return nil + } + } + return &domain.NotFoundError{Entity: "chat", ID: chatID} +} diff --git a/backend/internal/service/user.go b/backend/internal/service/user.go new file mode 100644 index 00000000..2fa8a87e --- /dev/null +++ b/backend/internal/service/user.go @@ -0,0 +1,76 @@ +package service + +import ( + "context" + "errors" + "regexp" + "strings" + "time" + "unicode/utf8" + + "github.com/google/uuid" + + "high-loud-apps-labs/internal/domain" +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +type UserService struct { + users domain.UserRepository +} + +func NewUserService(users domain.UserRepository) *UserService { + return &UserService{users: users} +} + +func (s *UserService) Create(ctx context.Context, username, displayName string) (*domain.User, error) { + if !usernamePattern.MatchString(username) { + return nil, &domain.ValidationError{ + Field: "username", + Message: "должен соответствовать ^[a-z0-9_]{3,32}$", + } + } + if strings.TrimSpace(displayName) == "" { + return nil, &domain.ValidationError{ + Field: "display_name", + Message: "не может состоять только из пробелов", + } + } + if utf8.RuneCountInString(displayName) > 100 { + return nil, &domain.ValidationError{ + Field: "display_name", + Message: "не более 100 символов", + } + } + + _, err := s.users.GetByUsername(ctx, username) + if err == nil { + return nil, &domain.AlreadyExistsError{ + Entity: "user", + Field: "username", + Value: username, + } + } + if !errors.Is(err, domain.ErrNotFound) { + return nil, err + } + + u := &domain.User{ + ID: uuid.NewString(), + Username: username, + DisplayName: displayName, + CreatedAt: time.Now().UTC(), + } + if err := s.users.Create(ctx, u); err != nil { + return nil, err + } + return u, nil +} + +func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) { + return s.users.GetByID(ctx, id) +} + +func (s *UserService) GetByUsername(ctx context.Context, username string) (*domain.User, error) { + return s.users.GetByUsername(ctx, username) +} diff --git a/backend/internal/storage/memory/chat.go b/backend/internal/storage/memory/chat.go new file mode 100644 index 00000000..a2e18d07 --- /dev/null +++ b/backend/internal/storage/memory/chat.go @@ -0,0 +1,102 @@ +package memory + +import ( + "context" + "slices" + + "high-loud-apps-labs/internal/domain" +) + +func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error { + if err := ctx.Err(); err != nil { + return err + } + r.mu.Lock() + defer r.mu.Unlock() + + stored := *chat + stored.MemberIDs = append([]string(nil), chat.MemberIDs...) + r.chats[chat.ID] = &stored + return nil +} + +func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) { + if err := ctx.Err(); err != nil { + return nil, err + } + r.mu.RLock() + defer r.mu.RUnlock() + + c, ok := r.chats[id] + if !ok { + return nil, &domain.NotFoundError{Entity: "chat", ID: id} + } + copy := *c + copy.MemberIDs = append([]string(nil), c.MemberIDs...) + return ©, nil +} + +func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) { + if err := ctx.Err(); err != nil { + return nil, nil, err + } + r.mu.RLock() + defer r.mu.RUnlock() + + scope := "chats:" + userID + + all := make([]domain.Chat, 0) + for _, c := range r.chats { + for _, m := range c.MemberIDs { + if m == userID { + copy := *c + copy.MemberIDs = append([]string(nil), c.MemberIDs...) + all = append(all, copy) + break + } + } + } + + slices.SortFunc(all, func(a, b domain.Chat) int { + if lessThan(a.CreatedAt, a.ID, b.CreatedAt, b.ID) { + return -1 + } + if lessThan(b.CreatedAt, b.ID, a.CreatedAt, a.ID) { + return 1 + } + return 0 + }) + + start := 0 + if cursor != nil { + t, id, err := decodeCursor(*cursor, scope) + if err != nil { + return nil, nil, err + } + start = len(all) + for i, c := range all { + if lessThan(t, id, c.CreatedAt, c.ID) { + start = i + break + } + } + } + + if start >= len(all) { + return []domain.Chat{}, nil, nil + } + end := start + limit + if end > len(all) { + end = len(all) + } + page := all[start:end] + + var next *string + if end < len(all) { + last := page[len(page)-1] + c := encodeCursor(scope, last.CreatedAt, last.ID) + next = &c + } + + return page, next, nil +} diff --git a/backend/internal/storage/memory/cursor.go b/backend/internal/storage/memory/cursor.go new file mode 100644 index 00000000..ef0ebac9 --- /dev/null +++ b/backend/internal/storage/memory/cursor.go @@ -0,0 +1,47 @@ +package memory + +import ( + "encoding/base64" + "strings" + "time" + + "high-loud-apps-labs/internal/domain" +) + +func encodeCursor(scope string, createdAt time.Time, id string) string { + raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id + return base64.RawURLEncoding.EncodeToString([]byte(raw)) +} + +func decodeCursor(cursor, expectedScope string) (time.Time, string, error) { + data, err := base64.RawURLEncoding.DecodeString(cursor) + if err != nil { + return time.Time{}, "", badCursor() + } + parts := strings.SplitN(string(data), "|", 3) + if len(parts) != 3 { + return time.Time{}, "", badCursor() + } + if parts[0] != expectedScope { + return time.Time{}, "", badCursor() + } + t, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil { + return time.Time{}, "", badCursor() + } + return t, parts[2], nil +} + +func badCursor() error { + return &domain.ValidationError{ + Field: "cursor", + Message: "некорректный формат", + } +} + +func lessThan(aTime time.Time, aID string, bTime time.Time, bID string) bool { + if aTime.Equal(bTime) { + return aID < bID + } + return aTime.Before(bTime) +} diff --git a/backend/internal/storage/memory/message.go b/backend/internal/storage/memory/message.go new file mode 100644 index 00000000..463b7578 --- /dev/null +++ b/backend/internal/storage/memory/message.go @@ -0,0 +1,93 @@ +package memory + +import ( + "context" + "slices" + "time" + + "high-loud-apps-labs/internal/domain" +) + +func (r *MessageRepo) Create(ctx context.Context, message *domain.Message) error { + if err := ctx.Err(); err != nil { + return err + } + r.mu.Lock() + defer r.mu.Unlock() + + stored := *message + r.messages[message.ChatID] = append(r.messages[message.ChatID], stored) + return nil +} + +func (r *MessageRepo) ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) { + if err := ctx.Err(); err != nil { + return nil, nil, err + } + r.mu.RLock() + defer r.mu.RUnlock() + + scope := "messages:" + chatID + + var ( + afterTime time.Time + afterID string + hasCursor bool + ) + if cursor != nil { + t, id, err := decodeCursor(*cursor, scope) + if err != nil { + return nil, nil, err + } + afterTime = t + afterID = id + hasCursor = true + } + + src := r.messages[chatID] + if len(src) == 0 { + return []domain.Message{}, nil, nil + } + + all := make([]domain.Message, len(src)) + copy(all, src) + + slices.SortFunc(all, func(a, b domain.Message) int { + if lessThan(a.CreatedAt, a.ID, b.CreatedAt, b.ID) { + return -1 + } + if lessThan(b.CreatedAt, b.ID, a.CreatedAt, a.ID) { + return 1 + } + return 0 + }) + + start := 0 + if hasCursor { + start = len(all) + for i, m := range all { + if lessThan(afterTime, afterID, m.CreatedAt, m.ID) { + start = i + break + } + } + } + + if start >= len(all) { + return []domain.Message{}, nil, nil + } + end := start + limit + if end > len(all) { + end = len(all) + } + page := all[start:end] + + var next *string + if end < len(all) { + last := page[len(page)-1] + c := encodeCursor(scope, last.CreatedAt, last.ID) + next = &c + } + + return page, next, nil +} diff --git a/backend/internal/storage/memory/storage.go b/backend/internal/storage/memory/storage.go new file mode 100644 index 00000000..5b967732 --- /dev/null +++ b/backend/internal/storage/memory/storage.go @@ -0,0 +1,34 @@ +package memory + +import ( + "sync" + + "high-loud-apps-labs/internal/domain" +) + +type Storage struct { + mu sync.RWMutex + users map[string]*domain.User + chats map[string]*domain.Chat + messages map[string][]domain.Message +} + +func New() *Storage { + return &Storage{ + users: make(map[string]*domain.User), + chats: make(map[string]*domain.Chat), + messages: make(map[string][]domain.Message), + } +} + +func (s *Storage) Users() *UserRepo { return &UserRepo{s} } +func (s *Storage) Chats() *ChatRepo { return &ChatRepo{s} } +func (s *Storage) Messages() *MessageRepo { return &MessageRepo{s} } + +type UserRepo struct{ *Storage } +type ChatRepo struct{ *Storage } +type MessageRepo struct{ *Storage } + +var _ domain.UserRepository = (*UserRepo)(nil) +var _ domain.ChatRepository = (*ChatRepo)(nil) +var _ domain.MessageRepository = (*MessageRepo)(nil) diff --git a/backend/internal/storage/memory/user.go b/backend/internal/storage/memory/user.go new file mode 100644 index 00000000..713162b5 --- /dev/null +++ b/backend/internal/storage/memory/user.go @@ -0,0 +1,59 @@ +package memory + +import ( + "context" + + "high-loud-apps-labs/internal/domain" +) + +func (r *UserRepo) Create(ctx context.Context, user *domain.User) error { + if err := ctx.Err(); err != nil { + return err + } + r.mu.Lock() + defer r.mu.Unlock() + + for _, u := range r.users { + if u.Username == user.Username { + return &domain.AlreadyExistsError{ + Entity: "user", + Field: "username", + Value: user.Username, + } + } + } + stored := *user + r.users[user.ID] = &stored + return nil +} + +func (r *UserRepo) GetByID(ctx context.Context, id string) (*domain.User, error) { + if err := ctx.Err(); err != nil { + return nil, err + } + r.mu.RLock() + defer r.mu.RUnlock() + + u, ok := r.users[id] + if !ok { + return nil, &domain.NotFoundError{Entity: "user", ID: id} + } + copy := *u + return ©, nil +} + +func (r *UserRepo) GetByUsername(ctx context.Context, username string) (*domain.User, error) { + if err := ctx.Err(); err != nil { + return nil, err + } + r.mu.RLock() + defer r.mu.RUnlock() + + for _, u := range r.users { + if u.Username == username { + copy := *u + return ©, nil + } + } + return nil, &domain.NotFoundError{Entity: "user", ID: username} +} diff --git a/student-tests/README.md b/student-tests/README.md new file mode 100644 index 00000000..0781b12d --- /dev/null +++ b/student-tests/README.md @@ -0,0 +1,7 @@ +# Собственные тесты + +Проверки негативных сценариев и конкурентной работы, отдельно от публичных `tests/`. + +Запуск (сервер уже должен быть поднят на `localhost:8080`): + + python students-tests/run_all.py --base-url http://localhost:8080 diff --git a/student-tests/run_all.py b/student-tests/run_all.py new file mode 100644 index 00000000..e089770d --- /dev/null +++ b/student-tests/run_all.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python3 +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parent + + +def main(): + args = sys.argv[1:] + for script in ('test_cases.py', 'test_concurrency.py'): + print(f'=== {script} ===') + result = subprocess.run([sys.executable, str(ROOT / script), *args]) + if result.returncode != 0: + sys.exit(result.returncode) + print('=== Все тесты прошли ===') + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/student-tests/test_cases.py b/student-tests/test_cases.py new file mode 100644 index 00000000..e939d66d --- /dev/null +++ b/student-tests/test_cases.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python3 +import sys +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, LAB, Failure, arguments, check, run # noqa: E402 + + +def main(): + args = arguments('Собственные тесты негативных сценариев') + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + path = '/api/v1/chats/' + chat['id'] + + # --- некорректный JSON --- + malformed = b'{"username":"alice","display_name":"A"' + c.call('POST', '/api/v1/users', 400, raw=malformed, + headers={'Content-Type': 'application/json'}) + + # --- лишнее поле --- + c.call('POST', '/api/v1/users', 400, + body={'username': 'u_' + uuid.uuid4().hex[:8], + 'display_name': 'X', 'extra': 'мусор'}) + + # --- неверный тип поля --- + c.call('POST', '/api/v1/users', 400, + body={'username': 123, 'display_name': 'X'}) + + # --- пустой display_name --- + c.call('POST', '/api/v1/users', 400, + body={'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': ''}) + + # --- display_name только из пробелов --- + c.call('POST', '/api/v1/users', 400, + body={'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': ' '}) + + # --- заглавные в username --- + c.call('POST', '/api/v1/users', 400, + body={'username': 'UPPERCASE', 'display_name': 'X'}) + + # --- дубликат username --- + c.call('POST', '/api/v1/users', 409, body=alice['registration']) + + # --- пустое сообщение --- + c.call('POST', path + '/messages', 400, actor=alice, body={'text': ''}) + + # --- сообщение только из пробелов --- + c.call('POST', path + '/messages', 400, actor=alice, body={'text': ' '}) + + # --- чужой чат --- + c.call('GET', path, 404, actor=eve) + c.call('GET', path + '/messages', 404, actor=eve) + c.call('POST', path + '/messages', 404, actor=eve, body={'text': 'чужое'}) + + # --- чат без создателя в member_ids --- + c.call('POST', '/api/v1/chats', 400, actor=alice, + body={'title': 'Без меня', 'member_ids': [bob['id']]}) + + # --- чат с неизвестным участником --- + c.call('POST', '/api/v1/chats', 400, actor=alice, + body={'title': 'С фантомом', + 'member_ids': [alice['id'], '00000000-0000-4000-8000-000000000000']}) + + # --- чат с дубликатами --- + c.call('POST', '/api/v1/chats', 400, actor=alice, + body={'title': 'Дубликаты', 'member_ids': [alice['id'], alice['id']]}) + + # --- обход нескольких страниц --- + for i in range(5): + c.message(alice, chat, 'page-test-%d' % i) + + seen = [] + cursor = None + for _ in range(20): + query = path + '/messages?limit=2' + if cursor: + from urllib.parse import quote + query += '&cursor=' + quote(cursor, safe='') + page = c.call('GET', query, actor=alice, schema='MessagePage')['json'] + seen.extend(x['id'] for x in page['items']) + cursor = page['next_cursor'] + if cursor is None: + break + check(len(seen) == len(set(seen)), 'пагинация вернула дубликаты') + check(len(seen) >= 5, 'пагинация потеряла сообщения') + + # --- cursor от другого чата --- + other_chat = c.call('POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Другой чат', + 'member_ids': [alice['id'], bob['id']]}, + schema='Chat')['json'] + other_path = '/api/v1/chats/' + other_chat['id'] + c.message(alice, other_chat, 'other-1') + c.message(alice, other_chat, 'other-2') + + other_page = c.call('GET', other_path + '/messages?limit=1', actor=alice, + schema='MessagePage')['json'] + other_cursor = other_page['next_cursor'] + check(other_cursor is not None, 'ожидался cursor от другого чата, но получен null') + + from urllib.parse import quote + c.call('GET', path + '/messages?limit=2&cursor=' + quote(other_cursor, safe=''), + 400, actor=alice) + + print('PASS: негативные сценарии прошли') + + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..9dee97a4 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +import threading +import uuid +from concurrent.futures import ThreadPoolExecutor + +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, LAB, Failure, arguments, check, run # noqa: E402 + + +def main(): + args = arguments('Собственные тесты конкурентности') + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + path = '/api/v1/chats/' + chat['id'] + + # --- 100 сообщений от 10 потоков --- + workers = 10 + per_worker = 10 + expected_total = workers * per_worker + barrier = threading.Barrier(workers) + + def writer(worker_id): + local = Client(args.base_url, args.ca_file, timeout=10) + barrier.wait() + for i in range(per_worker): + local.message(alice, chat, 'c-%d-%d' % (worker_id, i)) + + with ThreadPoolExecutor(max_workers=workers) as pool: + list(pool.map(writer, range(workers))) + + seen = [] + cursor = None + while True: + q = path + '/messages?limit=100' + if cursor: + from urllib.parse import quote + q += '&cursor=' + quote(cursor, safe='') + page = c.call('GET', q, actor=alice, schema='MessagePage')['json'] + seen.extend(x['id'] for x in page['items']) + cursor = page['next_cursor'] + if cursor is None: + break + + check(len(seen) == len(set(seen)), 'после параллельной записи обнаружены дубликаты id сообщений') + check(len(seen) == expected_total, + 'ожидалось ровно %d сообщений, получено %d' % (expected_total, len(seen))) + + # --- гонка за username --- + username = 'race_' + uuid.uuid4().hex[:8] + barrier2 = threading.Barrier(workers) + + def register(_): + local = Client(args.base_url, args.ca_file, timeout=10) + barrier2.wait() + try: + local.call('POST', '/api/v1/users', 201, + body={'username': username, 'display_name': 'Race'}) + return 'ok' + except Failure: + return 'conflict' + + with ThreadPoolExecutor(max_workers=workers) as pool: + results = list(pool.map(register, range(workers))) + + ok_count = results.count('ok') + conflict_count = results.count('conflict') + check(ok_count == 1, 'ожидалась ровно одна успешная регистрация, получено %d' % ok_count) + check(conflict_count == workers - 1, + 'ожидалось %d конфликтов, получено %d' % (workers - 1, conflict_count)) + + print('PASS: конкурентность (100 сообщений, 1 победитель в гонке за username)') + + +if __name__ == '__main__': + run(main) \ No newline at end of file -- 2.54.0 From 3d9e944c9a369e680055cfef4a46bdefd272a5c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 07:51:07 +0300 Subject: [PATCH 02/61] feat(backend.domain): lab2 add session and add password to user --- backend/internal/domain/entity.go | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/backend/internal/domain/entity.go b/backend/internal/domain/entity.go index ee00b9cd..6af98125 100644 --- a/backend/internal/domain/entity.go +++ b/backend/internal/domain/entity.go @@ -7,10 +7,11 @@ type Health struct { } type User struct { - ID string - Username string - DisplayName string - CreatedAt time.Time + ID string + Username string + DisplayName string + PasswordHash string // в DTO UserResponse его не будет + CreatedAt time.Time } type Chat struct { @@ -27,3 +28,10 @@ type Message struct { Text string CreatedAt time.Time } + +type Session struct { + TokenHash []byte + UserID string + ExpiresAt time.Time + CreatedAt time.Time +} -- 2.54.0 From 99df603bd45f0007d051713aa5d774c82f94ea0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 09:10:14 +0300 Subject: [PATCH 03/61] feat(backend.domain): lab2 add new errors and new session repo --- backend/internal/domain/errors.go | 26 +++++++++++++++++++------- backend/internal/domain/repository.go | 7 +++++++ 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/backend/internal/domain/errors.go b/backend/internal/domain/errors.go index 79f8a794..d3ec9be8 100644 --- a/backend/internal/domain/errors.go +++ b/backend/internal/domain/errors.go @@ -14,14 +14,16 @@ const ( CodeConflict ErrorCode = "conflict" CodeUnsupportedMediaType ErrorCode = "unsupported_media_type" CodeInternalError ErrorCode = "internal_error" + CodeUnavailable ErrorCode = "unavailable" ) var ( ErrNotFound = errors.New("не найдено") ErrAlreadyExists = errors.New("уже существует") ErrInvalidInput = errors.New("некорректные данные") - ErrForbidden = errors.New("доступ запрещён") + ErrUnauthorized = errors.New("требуется аутентификация") ErrUnsupportedMediaType = errors.New("неподдерживаемый тип содержимого") + ErrUnavailable = errors.New("сервис недоступен") ) type NotFoundError struct { @@ -58,15 +60,15 @@ func (e *ValidationError) Error() string { func (e *ValidationError) Unwrap() error { return ErrInvalidInput } func (e *ValidationError) Code() ErrorCode { return CodeInvalidRequest } -type ForbiddenError struct { - Reason string +type UnauthorizedError struct { + Reason string // для логов; в JSON не попадает } -func (e *ForbiddenError) Error() string { - return fmt.Sprintf("доступ запрещён: %s", e.Reason) +func (e *UnauthorizedError) Error() string { + return "требуется аутентификация" } -func (e *ForbiddenError) Unwrap() error { return ErrForbidden } -func (e *ForbiddenError) Code() ErrorCode { return CodeUnauthorized } +func (e *UnauthorizedError) Unwrap() error { return ErrUnauthorized } +func (e *UnauthorizedError) Code() ErrorCode { return CodeUnauthorized } type UnsupportedMediaTypeError struct { MediaType string @@ -80,3 +82,13 @@ func (e *UnsupportedMediaTypeError) Error() string { } func (e *UnsupportedMediaTypeError) Unwrap() error { return ErrUnsupportedMediaType } func (e *UnsupportedMediaTypeError) Code() ErrorCode { return CodeUnsupportedMediaType } + +type UnavailableError struct { + Reason string // для логов; в JSON не попадает +} + +func (e *UnavailableError) Error() string { + return "сервис временно недоступен" +} +func (e *UnavailableError) Unwrap() error { return ErrUnavailable } +func (e *UnavailableError) Code() ErrorCode { return CodeUnavailable } diff --git a/backend/internal/domain/repository.go b/backend/internal/domain/repository.go index 02d344d9..44065e09 100644 --- a/backend/internal/domain/repository.go +++ b/backend/internal/domain/repository.go @@ -12,9 +12,16 @@ type ChatRepository interface { Create(ctx context.Context, chat *Chat) error GetByID(ctx context.Context, id string) (*Chat, error) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]Chat, *string, error) + IsMember(ctx context.Context, chatID, userID string) (bool, error) } type MessageRepository interface { Create(ctx context.Context, message *Message) error ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]Message, *string, error) } + +type SessionRepository interface { + Create(ctx context.Context, session *Session) error + GetByTokenHash(ctx context.Context, tokenHash []byte) (*Session, error) + DeleteByTokenHash(ctx context.Context, tokenHash []byte) error +} -- 2.54.0 From 771f7aff076248fdbc53247c98b6aabb0a2dc39a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 09:14:12 +0300 Subject: [PATCH 04/61] fix(backend.domain): lab2 delete isMember in chat repo --- backend/internal/domain/repository.go | 1 - 1 file changed, 1 deletion(-) diff --git a/backend/internal/domain/repository.go b/backend/internal/domain/repository.go index 44065e09..1b980328 100644 --- a/backend/internal/domain/repository.go +++ b/backend/internal/domain/repository.go @@ -12,7 +12,6 @@ type ChatRepository interface { Create(ctx context.Context, chat *Chat) error GetByID(ctx context.Context, id string) (*Chat, error) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]Chat, *string, error) - IsMember(ctx context.Context, chatID, userID string) (bool, error) } type MessageRepository interface { -- 2.54.0 From 7def6015c411dab74ee1e3d9ef60fd89cff7491d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 09:43:13 +0300 Subject: [PATCH 05/61] feat(backend.dto): lab2 add password field in user creation and add new mistakes --- backend/internal/httpapi/dto/error.go | 23 ++++++++++++++++++----- backend/internal/httpapi/dto/user.go | 1 + 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/backend/internal/httpapi/dto/error.go b/backend/internal/httpapi/dto/error.go index 0fe6c002..4466e733 100644 --- a/backend/internal/httpapi/dto/error.go +++ b/backend/internal/httpapi/dto/error.go @@ -25,9 +25,14 @@ type coded interface { func ErrorFromDomain(err error, requestID string) ErrorResponse { var c coded if errors.As(err, &c) { + code := c.Code() + message := err.Error() + if code == domain.CodeInternalError { + message = "внутренняя ошибка" + } return ErrorResponse{Error: ErrorBody{ - Code: string(c.Code()), - Message: err.Error(), + Code: string(code), + Message: message, RequestID: requestID, }} } @@ -39,14 +44,20 @@ func ErrorFromDomain(err error, requestID string) ErrorResponse { code = domain.CodeConflict case errors.Is(err, domain.ErrInvalidInput): code = domain.CodeInvalidRequest - case errors.Is(err, domain.ErrForbidden): + case errors.Is(err, domain.ErrUnauthorized): code = domain.CodeUnauthorized case errors.Is(err, domain.ErrUnsupportedMediaType): code = domain.CodeUnsupportedMediaType + case errors.Is(err, domain.ErrUnavailable): + code = domain.CodeUnavailable + } + message := err.Error() + if code == domain.CodeInternalError { + message = "внутренняя ошибка" } return ErrorResponse{Error: ErrorBody{ Code: string(code), - Message: err.Error(), + Message: message, RequestID: requestID, }} } @@ -59,10 +70,12 @@ func StatusFromError(err error) int { return 409 case errors.Is(err, domain.ErrInvalidInput): return 400 - case errors.Is(err, domain.ErrForbidden): + case errors.Is(err, domain.ErrUnauthorized): return 401 case errors.Is(err, domain.ErrUnsupportedMediaType): return 415 + case errors.Is(err, domain.ErrUnavailable): + return 503 default: return 500 } diff --git a/backend/internal/httpapi/dto/user.go b/backend/internal/httpapi/dto/user.go index 07b9ebf0..0a027c19 100644 --- a/backend/internal/httpapi/dto/user.go +++ b/backend/internal/httpapi/dto/user.go @@ -9,6 +9,7 @@ const timeFormat = "2006-01-02T15:04:05.000000Z07:00" type CreateUserRequest struct { Username string `json:"username" binding:"required,min=3,max=32"` DisplayName string `json:"display_name" binding:"required,min=1,max=100"` + Password string `json:"password" binding:"required,min=12,max=128"` } type UserResponse struct { -- 2.54.0 From bc612c9a17383306582b904b6990524c3ebfe124 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 10:05:13 +0300 Subject: [PATCH 06/61] feat(backend.auth): lab2 change error --- backend/internal/httpapi/middleware/auth.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/backend/internal/httpapi/middleware/auth.go b/backend/internal/httpapi/middleware/auth.go index 589287fa..44e3f193 100644 --- a/backend/internal/httpapi/middleware/auth.go +++ b/backend/internal/httpapi/middleware/auth.go @@ -42,7 +42,7 @@ func CurrentUser(c *gin.Context) *domain.User { func abortUnauthorized(c *gin.Context, msg string) { reqID := GetRequestID(c) body := dto.ErrorFromDomain( - &domain.ForbiddenError{Reason: msg}, + &domain.UnauthorizedError{Reason: msg}, reqID, ) c.AbortWithStatusJSON(http.StatusUnauthorized, body) -- 2.54.0 From c3a555bf3d9e2ecb58e068676e369e8c247353c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 10:28:13 +0300 Subject: [PATCH 07/61] feat(backend.auth): Argon2idHasher with default OWASP config --- backend/internal/service/password.go | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 backend/internal/service/password.go diff --git a/backend/internal/service/password.go b/backend/internal/service/password.go new file mode 100644 index 00000000..a0c54b00 --- /dev/null +++ b/backend/internal/service/password.go @@ -0,0 +1,25 @@ +package service + +// PasswordHasher хеширует пароли и проверяет пароль сохранённого хеша. +type PasswordHasher interface { + Hash(password string) (string, error) + Verify(password, encoded string) (bool, error) +} + +type Argon2idHasher struct { + memory uint32 + iterations uint32 + parallelism uint8 + saltLength uint32 + keyLength uint32 +} + +func NewArgon2idHasher() *Argon2idHasher { + return &Argon2idHasher{ + memory: 64 * 1024, + iterations: 3, + parallelism: 4, + saltLength: 16, + keyLength: 32, + } +} -- 2.54.0 From bab61149cdef3fd5a33c99a56284e7a3dc365df7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 11:12:32 +0300 Subject: [PATCH 08/61] feat(backend.auth): add classic PHC Hasher --- backend/go.mod | 8 +++---- backend/go.sum | 16 ++++++------- backend/internal/service/password.go | 34 ++++++++++++++++++++++++++++ 3 files changed, 46 insertions(+), 12 deletions(-) diff --git a/backend/go.mod b/backend/go.mod index c2e4b21e..8188c5cd 100644 --- a/backend/go.mod +++ b/backend/go.mod @@ -5,6 +5,7 @@ go 1.26.1 require ( github.com/gin-gonic/gin v1.12.0 github.com/google/uuid v1.6.0 + golang.org/x/crypto v0.57.0 ) require ( @@ -32,9 +33,8 @@ require ( github.com/ugorji/go/codec v1.3.1 // indirect go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect golang.org/x/arch v0.22.0 // indirect - golang.org/x/crypto v0.48.0 // indirect - golang.org/x/net v0.51.0 // indirect - golang.org/x/sys v0.41.0 // indirect - golang.org/x/text v0.34.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/text v0.42.0 // indirect google.golang.org/protobuf v1.36.10 // indirect ) diff --git a/backend/go.sum b/backend/go.sum index 0b62b839..ef696d5b 100644 --- a/backend/go.sum +++ b/backend/go.sum @@ -74,15 +74,15 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI= golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= -golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts= -golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos= -golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo= -golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y= +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/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= -golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk= -golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA= +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.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/backend/internal/service/password.go b/backend/internal/service/password.go index a0c54b00..69ea1133 100644 --- a/backend/internal/service/password.go +++ b/backend/internal/service/password.go @@ -1,5 +1,13 @@ package service +import ( + "crypto/rand" + "encoding/base64" + "fmt" + + "golang.org/x/crypto/argon2" +) + // PasswordHasher хеширует пароли и проверяет пароль сохранённого хеша. type PasswordHasher interface { Hash(password string) (string, error) @@ -23,3 +31,29 @@ func NewArgon2idHasher() *Argon2idHasher { keyLength: 32, } } + +func (h *Argon2idHasher) Hash(password string) (string, error) { + salt := make([]byte, h.saltLength) + if _, err := rand.Read(salt); err != nil { + return "", fmt.Errorf("генерация соли: %w", err) + } + + key := argon2.IDKey( + []byte(password), + salt, + h.iterations, + h.memory, + h.parallelism, + h.keyLength, + ) + + return fmt.Sprintf( + "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, + h.memory, + h.iterations, + h.parallelism, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(key), + ), nil +} -- 2.54.0 From 7f3c85e709f94baff7afb7071e21206074b682e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 11:58:05 +0300 Subject: [PATCH 09/61] feat(backend.auth.service): lab2 add Verify --- backend/internal/service/password.go | 53 ++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/backend/internal/service/password.go b/backend/internal/service/password.go index 69ea1133..1f0659f1 100644 --- a/backend/internal/service/password.go +++ b/backend/internal/service/password.go @@ -2,8 +2,11 @@ package service import ( "crypto/rand" + "crypto/subtle" "encoding/base64" + "errors" "fmt" + "strings" "golang.org/x/crypto/argon2" ) @@ -57,3 +60,53 @@ func (h *Argon2idHasher) Hash(password string) (string, error) { base64.RawStdEncoding.EncodeToString(key), ), nil } + +// Verify сравнивает пароль с сохранённым PHC-хешем. +// Возвращает false и nil при неверном пароле. +// Возвращает false и ошибку, если строка хеша повреждена или несовместима. +func (h *Argon2idHasher) Verify(password, encoded string) (bool, error) { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" { + return false, errors.New("некорректный формат хеша") + } + + var version int + if n, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || n != 1 { + return false, errors.New("некорректная версия хеша") + } + if version != argon2.Version { + return false, errors.New("неподдерживаемая версия Argon2") + } + + var ( + memory uint32 + iterations uint32 + parallelism uint8 + ) + if n, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, ¶llelism); err != nil || n != 3 { + return false, errors.New("некорректные параметры хеша") + } + + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil { + return false, errors.New("некорректная соль") + } + + wantKey, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil { + return false, errors.New("некорректный ключ") + } + + gotKey := argon2.IDKey( + []byte(password), + salt, + iterations, + memory, + parallelism, + uint32(len(wantKey)), + ) + + return subtle.ConstantTimeCompare(gotKey, wantKey) == 1, nil +} + +var _ PasswordHasher = (*Argon2idHasher)(nil) -- 2.54.0 From 4ef6968a1c81e5266ff9350dd1ca9da3de541be5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 12:40:44 +0300 Subject: [PATCH 10/61] feat(migration): lab2 add goose init migration --- backend/migrations/0001_init.sql | 67 ++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 backend/migrations/0001_init.sql diff --git a/backend/migrations/0001_init.sql b/backend/migrations/0001_init.sql new file mode 100644 index 00000000..d9fad408 --- /dev/null +++ b/backend/migrations/0001_init.sql @@ -0,0 +1,67 @@ +-- +goose Up +-- +goose StatementBegin +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 now(), + CONSTRAINT users_username_format + CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_not_blank + CHECK (display_name !~ '^[[:space:]]*$'), + CONSTRAINT users_display_name_len + CHECK (char_length(display_name) <= 100), + CONSTRAINT users_password_hash_not_blank + CHECK (length(password_hash) > 0) +); +CREATE UNIQUE INDEX users_username_uniq ON users (username); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + CONSTRAINT chats_title_not_blank CHECK (title !~ '^[[:space:]]*$'), + CONSTRAINT chats_title_len CHECK (char_length(title) <= 100) +); +CREATE INDEX chats_created_id_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT, + joined_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT, + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + CONSTRAINT messages_text_not_blank CHECK (text !~ '^[[:space:]]*$'), + CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000) +); +CREATE INDEX messages_chat_created_id_idx + ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash BYTEA PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32) +); +CREATE INDEX sessions_user_idx ON sessions (user_id); +CREATE INDEX sessions_expires_idx ON sessions (expires_at); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS sessions; +DROP TABLE IF EXISTS messages; +DROP TABLE IF EXISTS chat_members; +DROP TABLE IF EXISTS chats; +DROP TABLE IF EXISTS users; +-- +goose StatementEnd \ No newline at end of file -- 2.54.0 From 5d2a7d0b20b9270574457d22e3b96aa8d9e4055e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 13:44:28 +0300 Subject: [PATCH 11/61] feat(service): lab2 add basic sessio service --- backend/internal/service/session.go | 42 +++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 backend/internal/service/session.go diff --git a/backend/internal/service/session.go b/backend/internal/service/session.go new file mode 100644 index 00000000..a393e28b --- /dev/null +++ b/backend/internal/service/session.go @@ -0,0 +1,42 @@ +package service + +import ( + "crypto/rand" + "encoding/base64" + "fmt" + "time" + + "high-loud-apps-labs/internal/domain" +) + +// SessionService отвечает за вход, проверку и отзыв сессий. +type SessionService struct { + users domain.UserRepository + sessions domain.SessionRepository + hasher PasswordHasher + ttl time.Duration +} + +// NewSessionService создаёт сервис с заданным TTL сессий. +func NewSessionService( + users domain.UserRepository, + sessions domain.SessionRepository, + hasher PasswordHasher, + ttl time.Duration, +) *SessionService { + return &SessionService{ + users: users, + sessions: sessions, + hasher: hasher, + ttl: ttl, + } +} + +// generateToken возвращает 32 случайных байта в base64url без паддинга=. +func generateToken() (string, error) { + buf := make([]byte, 32) + if _, err := rand.Read(buf); err != nil { + return "", fmt.Errorf("генерация токена: %w", err) + } + return base64.RawURLEncoding.EncodeToString(buf), nil +} -- 2.54.0 From 72f27d2ac3a3c4a2649cfec3dbc9b40f060397b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 14:42:35 +0300 Subject: [PATCH 12/61] feat(service): SessionService.Login with password verification and session creation --- backend/internal/service/session.go | 44 +++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/backend/internal/service/session.go b/backend/internal/service/session.go index a393e28b..8f203c66 100644 --- a/backend/internal/service/session.go +++ b/backend/internal/service/session.go @@ -1,8 +1,11 @@ package service import ( + "context" "crypto/rand" + "crypto/sha256" "encoding/base64" + "errors" "fmt" "time" @@ -32,6 +35,47 @@ func NewSessionService( } } +// Login проверяет username/password и создаёт новую сессию. +// Возвращает сессию, открытый токен и пользователя. +// Открытый токен уходит клиенту; в БД сохраняется только его SHA-256. +func (s *SessionService) Login(ctx context.Context, username, password string) (*domain.Session, string, *domain.User, error) { + user, err := s.users.GetByUsername(ctx, username) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + return nil, "", nil, &domain.UnauthorizedError{Reason: "неверные учётные данные"} + } + return nil, "", nil, err + } + + ok, err := s.hasher.Verify(password, user.PasswordHash) + if err != nil { + return nil, "", nil, err + } + if !ok { + return nil, "", nil, &domain.UnauthorizedError{Reason: "неверные учётные данные"} + } + + token, err := generateToken() + if err != nil { + return nil, "", nil, err + } + + tokenHash := sha256.Sum256([]byte(token)) + now := time.Now().UTC() + + session := &domain.Session{ + TokenHash: tokenHash[:], + UserID: user.ID, + ExpiresAt: now.Add(s.ttl), + CreatedAt: now, + } + if err := s.sessions.Create(ctx, session); err != nil { + return nil, "", nil, err + } + + return session, token, user, nil +} + // generateToken возвращает 32 случайных байта в base64url без паддинга=. func generateToken() (string, error) { buf := make([]byte, 32) -- 2.54.0 From 9d6b4e7fa26f3c6557936e90ec956a2d2be2d0db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 15:10:15 +0300 Subject: [PATCH 13/61] feat(service): lab2 SessionService add Resolve --- backend/internal/service/session.go | 32 +++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/backend/internal/service/session.go b/backend/internal/service/session.go index 8f203c66..cf2c1d72 100644 --- a/backend/internal/service/session.go +++ b/backend/internal/service/session.go @@ -76,6 +76,38 @@ func (s *SessionService) Login(ctx context.Context, username, password string) ( return session, token, user, nil } +// Resolve проверяет токен и возвращает пользователя сессии. +// Истёкший, отозванный или неизвестный токен - UnauthorizedError по контракту +func (s *SessionService) Resolve(ctx context.Context, token string) (*domain.User, error) { + if token == "" { + return nil, &domain.UnauthorizedError{Reason: "пустой токен"} + } + + tokenHash := sha256.Sum256([]byte(token)) + + session, err := s.sessions.GetByTokenHash(ctx, tokenHash[:]) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + return nil, &domain.UnauthorizedError{Reason: "неизвестный токен"} + } + return nil, err + } + + if !session.ExpiresAt.After(time.Now().UTC()) { + return nil, &domain.UnauthorizedError{Reason: "сессия истекла"} + } + + user, err := s.users.GetByID(ctx, session.UserID) + if err != nil { + if errors.Is(err, domain.ErrNotFound) { + return nil, &domain.UnauthorizedError{Reason: "пользователь сессии не найден"} + } + return nil, err + } + + return user, nil +} + // generateToken возвращает 32 случайных байта в base64url без паддинга=. func generateToken() (string, error) { buf := make([]byte, 32) -- 2.54.0 From 4161333bf80b0b5f001e41b7836b31d3b6a51aee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 15:21:44 +0300 Subject: [PATCH 14/61] feat(service): lab2 SessionService add Revoke --- backend/internal/service/session.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/backend/internal/service/session.go b/backend/internal/service/session.go index cf2c1d72..ee7216bf 100644 --- a/backend/internal/service/session.go +++ b/backend/internal/service/session.go @@ -108,6 +108,15 @@ func (s *SessionService) Resolve(ctx context.Context, token string) (*domain.Use return user, nil } +// Revoke удаляет сессию по токену. +func (s *SessionService) Revoke(ctx context.Context, token string) error { + if token == "" { + return nil + } + tokenHash := sha256.Sum256([]byte(token)) + return s.sessions.DeleteByTokenHash(ctx, tokenHash[:]) +} + // generateToken возвращает 32 случайных байта в base64url без паддинга=. func generateToken() (string, error) { buf := make([]byte, 32) -- 2.54.0 From cfabbfb5a02772dfb603fd570046b1267e9e4655 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 15:29:12 +0300 Subject: [PATCH 15/61] refactor(service): UserService accept PasswordHasher now --- backend/cmd/server/main.go | 4 +++- backend/internal/service/user.go | 20 ++++---------------- 2 files changed, 7 insertions(+), 17 deletions(-) diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index 4ca897a6..515d7165 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -22,7 +22,9 @@ func main() { store := memory.New() - userSvc := service.NewUserService(store.Users()) + hasher := service.NewArgon2idHasher() + + userSvc := service.NewUserService(store.Users(), hasher) chatSvc := service.NewChatService(store.Chats(), store.Users()) messageSvc := service.NewMessageService(store.Messages(), store.Chats()) diff --git a/backend/internal/service/user.go b/backend/internal/service/user.go index 2fa8a87e..ef5e9bad 100644 --- a/backend/internal/service/user.go +++ b/backend/internal/service/user.go @@ -2,7 +2,6 @@ package service import ( "context" - "errors" "regexp" "strings" "time" @@ -16,11 +15,12 @@ import ( var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) type UserService struct { - users domain.UserRepository + users domain.UserRepository + hasher PasswordHasher } -func NewUserService(users domain.UserRepository) *UserService { - return &UserService{users: users} +func NewUserService(users domain.UserRepository, hasher PasswordHasher) *UserService { + return &UserService{users: users, hasher: hasher} } func (s *UserService) Create(ctx context.Context, username, displayName string) (*domain.User, error) { @@ -43,18 +43,6 @@ func (s *UserService) Create(ctx context.Context, username, displayName string) } } - _, err := s.users.GetByUsername(ctx, username) - if err == nil { - return nil, &domain.AlreadyExistsError{ - Entity: "user", - Field: "username", - Value: username, - } - } - if !errors.Is(err, domain.ErrNotFound) { - return nil, err - } - u := &domain.User{ ID: uuid.NewString(), Username: username, -- 2.54.0 From df6dcd1d840c5d20c5ba474ada00ea07f251a2c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 15:57:55 +0300 Subject: [PATCH 16/61] feat(service): lab2 UserService.Create hash password --- backend/internal/httpapi/dto/user.go | 2 +- backend/internal/httpapi/handler/user.go | 2 +- backend/internal/service/user.go | 24 +++++++++++++++++++----- 3 files changed, 21 insertions(+), 7 deletions(-) diff --git a/backend/internal/httpapi/dto/user.go b/backend/internal/httpapi/dto/user.go index 0a027c19..08519414 100644 --- a/backend/internal/httpapi/dto/user.go +++ b/backend/internal/httpapi/dto/user.go @@ -9,7 +9,7 @@ const timeFormat = "2006-01-02T15:04:05.000000Z07:00" type CreateUserRequest struct { Username string `json:"username" binding:"required,min=3,max=32"` DisplayName string `json:"display_name" binding:"required,min=1,max=100"` - Password string `json:"password" binding:"required,min=12,max=128"` + Password string `json:"password" binding:"required,min=12,max=512"` } type UserResponse struct { diff --git a/backend/internal/httpapi/handler/user.go b/backend/internal/httpapi/handler/user.go index 35ad917a..7697b504 100644 --- a/backend/internal/httpapi/handler/user.go +++ b/backend/internal/httpapi/handler/user.go @@ -25,7 +25,7 @@ func (h *UserHandler) Create(c *gin.Context) { return } - u, err := h.users.Create(c.Request.Context(), req.Username, req.DisplayName) + u, err := h.users.Create(c.Request.Context(), req.Username, req.DisplayName, req.Password) if err != nil { respondError(c, err) return diff --git a/backend/internal/service/user.go b/backend/internal/service/user.go index ef5e9bad..e7b75479 100644 --- a/backend/internal/service/user.go +++ b/backend/internal/service/user.go @@ -23,7 +23,7 @@ func NewUserService(users domain.UserRepository, hasher PasswordHasher) *UserSer return &UserService{users: users, hasher: hasher} } -func (s *UserService) Create(ctx context.Context, username, displayName string) (*domain.User, error) { +func (s *UserService) Create(ctx context.Context, username, displayName, password string) (*domain.User, error) { if !usernamePattern.MatchString(username) { return nil, &domain.ValidationError{ Field: "username", @@ -43,11 +43,25 @@ func (s *UserService) Create(ctx context.Context, username, displayName string) } } + passwordRunes := utf8.RuneCountInString(password) + if passwordRunes < 12 || passwordRunes > 128 { + return nil, &domain.ValidationError{ + Field: "password", + Message: "длина 12–128 символов", + } + } + + hash, err := s.hasher.Hash(password) + if err != nil { + return nil, err + } + u := &domain.User{ - ID: uuid.NewString(), - Username: username, - DisplayName: displayName, - CreatedAt: time.Now().UTC(), + ID: uuid.NewString(), + Username: username, + DisplayName: displayName, + PasswordHash: hash, + CreatedAt: time.Now().UTC(), } if err := s.users.Create(ctx, u); err != nil { return nil, err -- 2.54.0 From 2355ed7bce5dc294517911f6d697c379fbc70020 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 16:27:51 +0300 Subject: [PATCH 17/61] feat(dto): lab2 SessionResponse for POST /auth/sessions --- backend/internal/httpapi/dto/session.go | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 backend/internal/httpapi/dto/session.go diff --git a/backend/internal/httpapi/dto/session.go b/backend/internal/httpapi/dto/session.go new file mode 100644 index 00000000..174430cf --- /dev/null +++ b/backend/internal/httpapi/dto/session.go @@ -0,0 +1,21 @@ +package dto + +import ( + "high-loud-apps-labs/internal/domain" +) + +type SessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User UserResponse `json:"user"` +} + +func SessionResponseFromDomain(s *domain.Session, token string, u *domain.User) SessionResponse { + return SessionResponse{ + Token: token, + TokenType: "Bearer", + ExpiresAt: s.ExpiresAt.UTC().Format(timeFormat), + User: UserFromDomain(u), + } +} -- 2.54.0 From 77b52891c0e4a416214c9e03c82082425b0bba5c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 17:22:51 +0300 Subject: [PATCH 18/61] =?UTF-8?q?feat(handler):=20lab2=20AuthHandler.Creat?= =?UTF-8?q?eSession=20=D1=81=20Basic?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/internal/httpapi/handler/auth.go | 59 ++++++++++++++++++++ backend/internal/httpapi/handler/response.go | 9 +++ 2 files changed, 68 insertions(+) create mode 100644 backend/internal/httpapi/handler/auth.go diff --git a/backend/internal/httpapi/handler/auth.go b/backend/internal/httpapi/handler/auth.go new file mode 100644 index 00000000..38bd22b8 --- /dev/null +++ b/backend/internal/httpapi/handler/auth.go @@ -0,0 +1,59 @@ +package handler + +import ( + "encoding/base64" + "net/http" + "strings" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/domain" + "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/service" +) + +type AuthHandler struct { + sessions *service.SessionService +} + +func NewAuthHandler(sessions *service.SessionService) *AuthHandler { + return &AuthHandler{sessions: sessions} +} + +func (h *AuthHandler) CreateSession(c *gin.Context) { + username, password, err := parseBasicAuth(c) + if err != nil { + respondBasicChallenge(c, err) + return + } + + session, token, user, err := h.sessions.Login(c.Request.Context(), username, password) + if err != nil { + respondBasicChallenge(c, err) + return + } + + c.JSON(http.StatusCreated, dto.SessionResponseFromDomain(session, token, user)) +} + +// parseBasicAuth читает Authorization: Basic base64(username:password). +func parseBasicAuth(c *gin.Context) (string, string, error) { + const prefix = "Basic " + + auth := c.GetHeader("Authorization") + if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) { + return "", "", &domain.UnauthorizedError{Reason: "требуется Basic"} + } + + decoded, err := base64.StdEncoding.DecodeString(auth[len(prefix):]) + if err != nil { + return "", "", &domain.UnauthorizedError{Reason: "некорректный Base64"} + } + + username, password, ok := strings.Cut(string(decoded), ":") + if !ok || username == "" { + return "", "", &domain.UnauthorizedError{Reason: "некорректный Basic-формат"} + } + + return username, password, nil +} diff --git a/backend/internal/httpapi/handler/response.go b/backend/internal/httpapi/handler/response.go index 5f066097..8cad0b3e 100644 --- a/backend/internal/httpapi/handler/response.go +++ b/backend/internal/httpapi/handler/response.go @@ -33,3 +33,12 @@ func respondError(c *gin.Context, err error) { reqID := middleware.GetRequestID(c) c.JSON(dto.StatusFromError(err), dto.ErrorFromDomain(err, reqID)) } + +// respondBasicChallenge выставляет WWW-Authenticate для 401 на /auth/sessions. +// На не-401 ответах заголовок не ставится как по контракту нужно +func respondBasicChallenge(c *gin.Context, err error) { + if dto.StatusFromError(err) == 401 { + c.Header("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + } + respondError(c, err) +} -- 2.54.0 From f4a7f77926c0e0502ebe5d4f7d4f37d20d40b37c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 18:02:51 +0300 Subject: [PATCH 19/61] refactor(middleware): lab2 put CurrentUser/CurrentToken from auth to context.go --- backend/internal/httpapi/middleware/auth.go | 11 ------- .../internal/httpapi/middleware/context.go | 30 +++++++++++++++++++ 2 files changed, 30 insertions(+), 11 deletions(-) create mode 100644 backend/internal/httpapi/middleware/context.go diff --git a/backend/internal/httpapi/middleware/auth.go b/backend/internal/httpapi/middleware/auth.go index 44e3f193..e3192dab 100644 --- a/backend/internal/httpapi/middleware/auth.go +++ b/backend/internal/httpapi/middleware/auth.go @@ -9,8 +9,6 @@ import ( "high-loud-apps-labs/internal/httpapi/dto" ) -const CurrentUserKey = "current_user" - func Auth(users domain.UserRepository) gin.HandlerFunc { return func(c *gin.Context) { id := c.GetHeader("X-User-Id") @@ -30,15 +28,6 @@ func Auth(users domain.UserRepository) gin.HandlerFunc { } } -func CurrentUser(c *gin.Context) *domain.User { - if v, ok := c.Get(CurrentUserKey); ok { - if u, ok := v.(*domain.User); ok { - return u - } - } - return nil -} - func abortUnauthorized(c *gin.Context, msg string) { reqID := GetRequestID(c) body := dto.ErrorFromDomain( diff --git a/backend/internal/httpapi/middleware/context.go b/backend/internal/httpapi/middleware/context.go new file mode 100644 index 00000000..f467d367 --- /dev/null +++ b/backend/internal/httpapi/middleware/context.go @@ -0,0 +1,30 @@ +package middleware + +import ( + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/domain" +) + +const ( + CurrentUserKey = "current_user" + CurrentTokenKey = "current_token" +) + +func CurrentUser(c *gin.Context) *domain.User { + if v, ok := c.Get(CurrentUserKey); ok { + if u, ok := v.(*domain.User); ok { + return u + } + } + return nil +} + +func CurrentToken(c *gin.Context) string { + if v, ok := c.Get(CurrentTokenKey); ok { + if s, ok := v.(string); ok { + return s + } + } + return "" +} -- 2.54.0 From 81e480a857fe663e453fa4eb6fe4637f64a59d89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 19:07:11 +0300 Subject: [PATCH 20/61] feat(middleware): lab2 BearerAuth with session check --- backend/internal/httpapi/middleware/bearer.go | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 backend/internal/httpapi/middleware/bearer.go diff --git a/backend/internal/httpapi/middleware/bearer.go b/backend/internal/httpapi/middleware/bearer.go new file mode 100644 index 00000000..6e04a916 --- /dev/null +++ b/backend/internal/httpapi/middleware/bearer.go @@ -0,0 +1,63 @@ +package middleware + +import ( + "strings" + + "github.com/gin-gonic/gin" + + "high-loud-apps-labs/internal/domain" + "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/service" +) + +// BearerAuth читает Authorization: Bearer , проверяет сессию +// через SessionService и кладёт пользователя и токен в контекст. +func BearerAuth(sessions *service.SessionService) gin.HandlerFunc { + return func(c *gin.Context) { + token, ok := parseBearerToken(c) + if !ok { + abortBearer(c, "требуется Bearer") + return + } + + user, err := sessions.Resolve(c.Request.Context(), token) + if err != nil { + abortBearerWithErr(c, err) + return + } + + c.Set(CurrentUserKey, user) + c.Set(CurrentTokenKey, token) + c.Next() + } +} + +// parseBearerToken читает Authorization: Bearer . +func parseBearerToken(c *gin.Context) (string, bool) { + const prefix = "Bearer " + auth := c.GetHeader("Authorization") + if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) { + return "", false + } + token := strings.TrimSpace(auth[len(prefix):]) + if token == "" { + return "", false + } + return token, true +} + +func abortBearer(c *gin.Context, reason string) { + abortBearerWithErr(c, &domain.UnauthorizedError{Reason: reason}) +} + +// abortBearerWithErr формирует ответ на ошибку аутентификации. +// Заголовок WWW-Authenticate: Bearer выставляется только на 401; +// при 503 (недоступность БД) - обычный ответ ошибки без challenge. +func abortBearerWithErr(c *gin.Context, err error) { + reqID := GetRequestID(c) + status := dto.StatusFromError(err) + if status == 401 { + c.Header("WWW-Authenticate", `Bearer realm="messenger"`) + } + c.AbortWithStatusJSON(status, dto.ErrorFromDomain(err, reqID)) +} -- 2.54.0 From fa252ccf0489a66734f34794bb6af10e080386fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 19:15:17 +0300 Subject: [PATCH 21/61] feat(storage/postgres): lab2 add embed for migrations --- backend/migrations/embed.go | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 backend/migrations/embed.go diff --git a/backend/migrations/embed.go b/backend/migrations/embed.go new file mode 100644 index 00000000..91cca1c3 --- /dev/null +++ b/backend/migrations/embed.go @@ -0,0 +1,6 @@ +package migrations + +import "embed" + +//go:embed *.sql +var FS embed.FS -- 2.54.0 From a8b787eccb8b0cd13ecefdae96959ad55931579f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 19:58:27 +0300 Subject: [PATCH 22/61] feat(storage/postgres): lab2 add pool connection and migrations runner --- backend/internal/storage/postgres/db.go | 75 +++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 backend/internal/storage/postgres/db.go diff --git a/backend/internal/storage/postgres/db.go b/backend/internal/storage/postgres/db.go new file mode 100644 index 00000000..d1f406e3 --- /dev/null +++ b/backend/internal/storage/postgres/db.go @@ -0,0 +1,75 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + "github.com/jackc/pgx/v5/stdlib" + "github.com/pressly/goose/v3" + + "high-loud-apps-labs/migrations" +) + +type Config struct { + URL string + MaxConns int32 + MinConns int32 + MaxConnLifetime time.Duration + MaxConnIdleTime time.Duration + ConnectTimeout time.Duration +} + +func Connect(ctx context.Context, cfg Config) (*pgxpool.Pool, error) { + if cfg.URL == "" { + return nil, fmt.Errorf("DATABASE_URL пустой") + } + + poolCfg, err := pgxpool.ParseConfig(cfg.URL) + if err != nil { + return nil, fmt.Errorf("разбор DATABASE_URL: %w", err) + } + if cfg.MaxConns > 0 { + poolCfg.MaxConns = cfg.MaxConns + } + if cfg.MinConns > 0 { + poolCfg.MinConns = cfg.MinConns + } + if cfg.MaxConnLifetime > 0 { + poolCfg.MaxConnLifetime = cfg.MaxConnLifetime + } + if cfg.MaxConnIdleTime > 0 { + poolCfg.MaxConnIdleTime = cfg.MaxConnIdleTime + } + if cfg.ConnectTimeout > 0 { + poolCfg.ConnConfig.ConnectTimeout = cfg.ConnectTimeout + } + + pool, err := pgxpool.NewWithConfig(ctx, poolCfg) + if err != nil { + return nil, fmt.Errorf("создание пула: %w", err) + } + + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping БД: %w", err) + } + return pool, nil +} + +func RunMigrations(ctx context.Context, pool *pgxpool.Pool) error { + db := stdlib.OpenDBFromPool(pool) + defer db.Close() + + goose.SetBaseFS(migrations.FS) + if err := goose.SetDialect("postgres"); err != nil { + return fmt.Errorf("goose dialect: %w", err) + } + if err := goose.UpContext(ctx, db, "."); err != nil { + return fmt.Errorf("применение миграций: %w", err) + } + return nil +} -- 2.54.0 From 3e623d4fea9ee957f8821e3dfb2a0ddd9619743f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 20:42:11 +0300 Subject: [PATCH 23/61] feat(storage/postgres): lab2 add pg error helpers and keyset cursor --- backend/internal/storage/postgres/cursor.go | 41 ++++++++++++++++++++ backend/internal/storage/postgres/errors.go | 42 +++++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 backend/internal/storage/postgres/cursor.go create mode 100644 backend/internal/storage/postgres/errors.go diff --git a/backend/internal/storage/postgres/cursor.go b/backend/internal/storage/postgres/cursor.go new file mode 100644 index 00000000..4349c070 --- /dev/null +++ b/backend/internal/storage/postgres/cursor.go @@ -0,0 +1,41 @@ +package postgres + +import ( + "encoding/base64" + "strings" + "time" + + "high-loud-apps-labs/internal/domain" +) + +// Взял за основу что в inmemery делал +func encodeCursor(scope string, createdAt time.Time, id string) string { + raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id + return base64.RawURLEncoding.EncodeToString([]byte(raw)) +} + +func decodeCursor(cursor, expectedScope string) (time.Time, string, error) { + data, err := base64.RawURLEncoding.DecodeString(cursor) + if err != nil { + return time.Time{}, "", badCursor() + } + parts := strings.SplitN(string(data), "|", 3) + if len(parts) != 3 { + return time.Time{}, "", badCursor() + } + if parts[0] != expectedScope { + return time.Time{}, "", badCursor() + } + t, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil { + return time.Time{}, "", badCursor() + } + return t, parts[2], nil +} + +func badCursor() error { + return &domain.ValidationError{ + Field: "cursor", + Message: "некорректный формат", + } +} diff --git a/backend/internal/storage/postgres/errors.go b/backend/internal/storage/postgres/errors.go new file mode 100644 index 00000000..905d0bf1 --- /dev/null +++ b/backend/internal/storage/postgres/errors.go @@ -0,0 +1,42 @@ +package postgres + +import ( + "errors" + + "github.com/jackc/pgerrcode" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + + "high-loud-apps-labs/internal/domain" +) + +func notFound(err error, entity, id string) error { + if errors.Is(err, pgx.ErrNoRows) { + return &domain.NotFoundError{Entity: entity, ID: id} + } + return err +} + +func uniqueViolation(err error) bool { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + return pgErr.Code == pgerrcode.UniqueViolation + } + return false +} + +func foreignKeyViolation(err error) bool { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + return pgErr.Code == pgerrcode.ForeignKeyViolation + } + return false +} + +func checkViolation(err error) bool { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + return pgErr.Code == pgerrcode.CheckViolation + } + return false +} -- 2.54.0 From 98a37565288698e32571b2968d46db9e9a1c61f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 21:16:58 +0300 Subject: [PATCH 24/61] feat(storage/postgres): lab2 add UserRepo --- backend/internal/storage/postgres/user.go | 76 +++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 backend/internal/storage/postgres/user.go diff --git a/backend/internal/storage/postgres/user.go b/backend/internal/storage/postgres/user.go new file mode 100644 index 00000000..804b9552 --- /dev/null +++ b/backend/internal/storage/postgres/user.go @@ -0,0 +1,76 @@ +package postgres + +import ( + "context" + + "github.com/jackc/pgx/v5/pgxpool" + + "high-loud-apps-labs/internal/domain" +) + +type UserRepo struct { + pool *pgxpool.Pool +} + +func NewUserRepo(pool *pgxpool.Pool) *UserRepo { + return &UserRepo{pool: pool} +} + +func (r *UserRepo) Create(ctx context.Context, user *domain.User) error { + const q = ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1::uuid, $2, $3, $4, $5) + ` + _, err := r.pool.Exec(ctx, q, + user.ID, user.Username, user.DisplayName, user.PasswordHash, user.CreatedAt, + ) + if err != nil { + if uniqueViolation(err) { + return &domain.AlreadyExistsError{ + Entity: "user", + Field: "username", + Value: user.Username, + } + } + if checkViolation(err) { + return &domain.ValidationError{ + Field: "user", + Message: "нарушено ограничение целостности", + } + } + return err + } + return nil +} + +func (r *UserRepo) GetByID(ctx context.Context, id string) (*domain.User, error) { + const q = ` + SELECT id, username, display_name, password_hash, created_at + FROM users + WHERE id = $1::uuid + ` + u := &domain.User{} + err := r.pool.QueryRow(ctx, q, id). + Scan(&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt) + if err != nil { + return nil, notFound(err, "user", id) + } + return u, nil +} + +func (r *UserRepo) GetByUsername(ctx context.Context, username string) (*domain.User, error) { + const q = ` + SELECT id, username, display_name, password_hash, created_at + FROM users + WHERE username = $1 + ` + u := &domain.User{} + err := r.pool.QueryRow(ctx, q, username). + Scan(&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt) + if err != nil { + return nil, notFound(err, "user", username) + } + return u, nil +} + +var _ domain.UserRepository = (*UserRepo)(nil) -- 2.54.0 From b72ddd127c7a7547ad1e5f0d0195e338f32524f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Thu, 1 Oct 2026 22:39:18 +0300 Subject: [PATCH 25/61] feat(storage/postgres): lab2 add SessionRepo --- backend/internal/storage/postgres/session.go | 59 ++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 backend/internal/storage/postgres/session.go diff --git a/backend/internal/storage/postgres/session.go b/backend/internal/storage/postgres/session.go new file mode 100644 index 00000000..fa983aa0 --- /dev/null +++ b/backend/internal/storage/postgres/session.go @@ -0,0 +1,59 @@ +package postgres + +import ( + "context" + + "github.com/jackc/pgx/v5/pgxpool" + + "high-loud-apps-labs/internal/domain" +) + +type SessionRepo struct { + pool *pgxpool.Pool +} + +func NewSessionRepo(pool *pgxpool.Pool) *SessionRepo { + return &SessionRepo{pool: pool} +} + +func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error { + const q = ` + INSERT INTO sessions (token_hash, user_id, expires_at, created_at) + VALUES ($1, $2::uuid, $3, $4) + ` + _, err := r.pool.Exec(ctx, q, s.TokenHash, s.UserID, s.ExpiresAt, s.CreatedAt) + if err != nil { + if uniqueViolation(err) { + return &domain.AlreadyExistsError{ + Entity: "session", + Field: "token_hash", + Value: "", + } + } + return err + } + return nil +} + +func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*domain.Session, error) { + const q = ` + SELECT token_hash, user_id, expires_at, created_at + FROM sessions + WHERE token_hash = $1 + ` + s := &domain.Session{} + err := r.pool.QueryRow(ctx, q, tokenHash). + Scan(&s.TokenHash, &s.UserID, &s.ExpiresAt, &s.CreatedAt) + if err != nil { + return nil, notFound(err, "session", "") + } + return s, nil +} + +func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error { + const q = `DELETE FROM sessions WHERE token_hash = $1` + _, err := r.pool.Exec(ctx, q, tokenHash) + return err +} + +var _ domain.SessionRepository = (*SessionRepo)(nil) -- 2.54.0 From 66af1891ac78758b112a57c361e14a4a05488837 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 00:16:52 +0300 Subject: [PATCH 26/61] feat(storage/postgres): lab2 add ChatRepo with atomic create and members batch load --- backend/internal/storage/postgres/chat.go | 195 ++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 backend/internal/storage/postgres/chat.go diff --git a/backend/internal/storage/postgres/chat.go b/backend/internal/storage/postgres/chat.go new file mode 100644 index 00000000..1c430d0e --- /dev/null +++ b/backend/internal/storage/postgres/chat.go @@ -0,0 +1,195 @@ +package postgres + +import ( + "context" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "high-loud-apps-labs/internal/domain" +) + +type ChatRepo struct { + pool *pgxpool.Pool +} + +func NewChatRepo(pool *pgxpool.Pool) *ChatRepo { + return &ChatRepo{pool: pool} +} + +// Create атомарно создаёт чат и его участников. +func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return err + } + defer func() { _ = tx.Rollback(ctx) }() + + const qChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)` + if _, err := tx.Exec(ctx, qChat, chat.ID, chat.Title, chat.CreatedAt); err != nil { + if checkViolation(err) { + return &domain.ValidationError{Field: "chat", Message: "нарушено ограничение целостности"} + } + return err + } + + const qMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)` + for _, uid := range chat.MemberIDs { + if _, err := tx.Exec(ctx, qMember, chat.ID, uid); err != nil { + if foreignKeyViolation(err) { + return &domain.ValidationError{ + Field: "member_ids", + Message: "неизвестный участник " + uid, + } + } + if uniqueViolation(err) { + return &domain.ValidationError{ + Field: "member_ids", + Message: "дубликаты запрещены", + } + } + return err + } + } + + return tx.Commit(ctx) +} + +func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) { + const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid` + c := &domain.Chat{} + err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt) + if err != nil { + return nil, notFound(err, "chat", id) + } + members, err := r.loadMembers(ctx, []string{c.ID}) + if err != nil { + return nil, err + } + c.MemberIDs = members[c.ID] + if c.MemberIDs == nil { + c.MemberIDs = []string{} + } + return c, nil +} + +func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) { + scope := "chats:" + userID + + var ( + afterTime time.Time + afterID string + hasCursor bool + ) + if cursor != nil { + t, id, err := decodeCursor(*cursor, scope) + if err != nil { + return nil, nil, err + } + afterTime = t + afterID = id + hasCursor = true + } + + var ( + rows pgx.Rows + err error + ) + if hasCursor { + const q = ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1::uuid + AND (c.created_at, c.id) > ($2, $3::uuid) + ORDER BY c.created_at, c.id + LIMIT $4 + ` + rows, err = r.pool.Query(ctx, q, userID, afterTime, afterID, limit+1) + } else { + const q = ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1::uuid + ORDER BY c.created_at, c.id + LIMIT $2 + ` + rows, err = r.pool.Query(ctx, q, userID, limit+1) + } + if err != nil { + return nil, nil, err + } + defer rows.Close() + + page := make([]domain.Chat, 0, limit) + for rows.Next() { + var c domain.Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, nil, err + } + page = append(page, c) + } + if err := rows.Err(); err != nil { + return nil, nil, err + } + + var next *string + if len(page) > limit { + page = page[:limit] + last := page[len(page)-1] + c := encodeCursor(scope, last.CreatedAt, last.ID) + next = &c + } + + if len(page) > 0 { + ids := make([]string, len(page)) + for i := range page { + ids[i] = page[i].ID + } + members, err := r.loadMembers(ctx, ids) + if err != nil { + return nil, nil, err + } + for i := range page { + if m, ok := members[page[i].ID]; ok { + page[i].MemberIDs = m + } else { + page[i].MemberIDs = []string{} + } + } + } + + return page, next, nil +} + +// loadMembers одним запросом собирает участников для указанных чатов. +func (r *ChatRepo) loadMembers(ctx context.Context, chatIDs []string) (map[string][]string, error) { + if len(chatIDs) == 0 { + return map[string][]string{}, nil + } + const q = ` + SELECT chat_id, user_id + FROM chat_members + WHERE chat_id = ANY($1::uuid[]) + ORDER BY chat_id, user_id + ` + rows, err := r.pool.Query(ctx, q, chatIDs) + if err != nil { + return nil, err + } + defer rows.Close() + + result := make(map[string][]string, len(chatIDs)) + for rows.Next() { + var chatID, userID string + if err := rows.Scan(&chatID, &userID); err != nil { + return nil, err + } + result[chatID] = append(result[chatID], userID) + } + return result, rows.Err() +} + +var _ domain.ChatRepository = (*ChatRepo)(nil) -- 2.54.0 From 5142ed5fe3f35d29f355f45d724aa12f7acd90a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 01:12:02 +0300 Subject: [PATCH 27/61] feat(storage/postgres): lab2 add MessageRepo with keyset pagination --- backend/internal/storage/postgres/message.go | 108 +++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 backend/internal/storage/postgres/message.go diff --git a/backend/internal/storage/postgres/message.go b/backend/internal/storage/postgres/message.go new file mode 100644 index 00000000..cd1cdc32 --- /dev/null +++ b/backend/internal/storage/postgres/message.go @@ -0,0 +1,108 @@ +package postgres + +import ( + "context" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "high-loud-apps-labs/internal/domain" +) + +type MessageRepo struct { + pool *pgxpool.Pool +} + +func NewMessageRepo(pool *pgxpool.Pool) *MessageRepo { + return &MessageRepo{pool: pool} +} + +func (r *MessageRepo) Create(ctx context.Context, m *domain.Message) error { + const q = ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5) + ` + _, err := r.pool.Exec(ctx, q, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt) + if err != nil { + if foreignKeyViolation(err) { + return &domain.NotFoundError{Entity: "chat", ID: m.ChatID} + } + if checkViolation(err) { + return &domain.ValidationError{Field: "text", Message: "нарушено ограничение"} + } + return err + } + return nil +} + +func (r *MessageRepo) ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) { + scope := "messages:" + chatID + + var ( + afterTime time.Time + afterID string + hasCursor bool + ) + if cursor != nil { + t, id, err := decodeCursor(*cursor, scope) + if err != nil { + return nil, nil, err + } + afterTime = t + afterID = id + hasCursor = true + } + + var ( + rows pgx.Rows + err error + ) + if hasCursor { + const q = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1::uuid + AND (created_at, id) > ($2, $3::uuid) + ORDER BY created_at, id + LIMIT $4 + ` + rows, err = r.pool.Query(ctx, q, chatID, afterTime, afterID, limit+1) + } else { + const q = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1::uuid + ORDER BY created_at, id + LIMIT $2 + ` + rows, err = r.pool.Query(ctx, q, chatID, limit+1) + } + if err != nil { + return nil, nil, err + } + defer rows.Close() + + page := make([]domain.Message, 0, limit) + for rows.Next() { + var m domain.Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil { + return nil, nil, err + } + page = append(page, m) + } + if err := rows.Err(); err != nil { + return nil, nil, err + } + + var next *string + if len(page) > limit { + page = page[:limit] + last := page[len(page)-1] + c := encodeCursor(scope, last.CreatedAt, last.ID) + next = &c + } + return page, next, nil +} + +var _ domain.MessageRepository = (*MessageRepo)(nil) -- 2.54.0 From 322ef09c1f6afe0c0bc3bca45202c29548a56f67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 01:41:25 +0300 Subject: [PATCH 28/61] feat(storage/postgres): lab2 add Storage wrapper and interface assertions --- backend/internal/storage/postgres/storage.go | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 backend/internal/storage/postgres/storage.go diff --git a/backend/internal/storage/postgres/storage.go b/backend/internal/storage/postgres/storage.go new file mode 100644 index 00000000..110fef13 --- /dev/null +++ b/backend/internal/storage/postgres/storage.go @@ -0,0 +1,18 @@ +package postgres + +import "github.com/jackc/pgx/v5/pgxpool" + +type Storage struct { + pool *pgxpool.Pool +} + +func New(pool *pgxpool.Pool) *Storage { + return &Storage{pool: pool} +} + +func (s *Storage) Pool() *pgxpool.Pool { return s.pool } + +func (s *Storage) Users() *UserRepo { return &UserRepo{pool: s.pool} } +func (s *Storage) Chats() *ChatRepo { return &ChatRepo{pool: s.pool} } +func (s *Storage) Messages() *MessageRepo { return &MessageRepo{pool: s.pool} } +func (s *Storage) Sessions() *SessionRepo { return &SessionRepo{pool: s.pool} } -- 2.54.0 From 45b3606259b65d7aaeb608708e2d9e2c9bc1c717 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 08:55:21 +0300 Subject: [PATCH 29/61] fix(postgres): map driver errors and keep shared pool after migrations --- backend/internal/storage/postgres/db.go | 1 - backend/internal/storage/postgres/errors.go | 28 ++++++++++++++++++++- 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/backend/internal/storage/postgres/db.go b/backend/internal/storage/postgres/db.go index d1f406e3..875a88c5 100644 --- a/backend/internal/storage/postgres/db.go +++ b/backend/internal/storage/postgres/db.go @@ -62,7 +62,6 @@ func Connect(ctx context.Context, cfg Config) (*pgxpool.Pool, error) { func RunMigrations(ctx context.Context, pool *pgxpool.Pool) error { db := stdlib.OpenDBFromPool(pool) - defer db.Close() goose.SetBaseFS(migrations.FS) if err := goose.SetDialect("postgres"); err != nil { diff --git a/backend/internal/storage/postgres/errors.go b/backend/internal/storage/postgres/errors.go index 905d0bf1..a3a4de3c 100644 --- a/backend/internal/storage/postgres/errors.go +++ b/backend/internal/storage/postgres/errors.go @@ -1,6 +1,7 @@ package postgres import ( + "context" "errors" "github.com/jackc/pgerrcode" @@ -10,11 +11,36 @@ import ( "high-loud-apps-labs/internal/domain" ) +type coded interface { + Code() domain.ErrorCode +} + +// mapError переводит ошибки драйвера в доменные. +func mapError(err error) error { + if err == nil { + return nil + } + var c coded + if errors.As(err, &c) { + return err + } + if errors.Is(err, pgx.ErrNoRows) { + return err + } + if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { + return err + } + return &domain.UnavailableError{Reason: err.Error()} +} + func notFound(err error, entity, id string) error { + if err == nil { + return nil + } if errors.Is(err, pgx.ErrNoRows) { return &domain.NotFoundError{Entity: entity, ID: id} } - return err + return mapError(err) } func uniqueViolation(err error) bool { -- 2.54.0 From 537ec40c8a2ff060d8858f9298fcf5be446c589c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 09:12:21 +0300 Subject: [PATCH 30/61] fix(postgres): map drivers --- backend/internal/storage/postgres/chat.go | 20 ++++++++++---------- backend/internal/storage/postgres/session.go | 4 ++-- backend/internal/storage/postgres/user.go | 2 +- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/backend/internal/storage/postgres/chat.go b/backend/internal/storage/postgres/chat.go index 1c430d0e..8afc6f29 100644 --- a/backend/internal/storage/postgres/chat.go +++ b/backend/internal/storage/postgres/chat.go @@ -22,7 +22,7 @@ func NewChatRepo(pool *pgxpool.Pool) *ChatRepo { func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error { tx, err := r.pool.Begin(ctx) if err != nil { - return err + return mapError(err) } defer func() { _ = tx.Rollback(ctx) }() @@ -31,7 +31,7 @@ func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error { if checkViolation(err) { return &domain.ValidationError{Field: "chat", Message: "нарушено ограничение целостности"} } - return err + return mapError(err) } const qMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)` @@ -49,11 +49,11 @@ func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error { Message: "дубликаты запрещены", } } - return err + return mapError(err) } } - return tx.Commit(ctx) + return mapError(tx.Commit(ctx)) } func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) { @@ -119,7 +119,7 @@ func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, c rows, err = r.pool.Query(ctx, q, userID, limit+1) } if err != nil { - return nil, nil, err + return nil, nil, mapError(err) } defer rows.Close() @@ -127,12 +127,12 @@ func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, c for rows.Next() { var c domain.Chat if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { - return nil, nil, err + return nil, nil, mapError(err) } page = append(page, c) } if err := rows.Err(); err != nil { - return nil, nil, err + return nil, nil, mapError(err) } var next *string @@ -177,7 +177,7 @@ func (r *ChatRepo) loadMembers(ctx context.Context, chatIDs []string) (map[strin ` rows, err := r.pool.Query(ctx, q, chatIDs) if err != nil { - return nil, err + return nil, mapError(err) } defer rows.Close() @@ -185,11 +185,11 @@ func (r *ChatRepo) loadMembers(ctx context.Context, chatIDs []string) (map[strin for rows.Next() { var chatID, userID string if err := rows.Scan(&chatID, &userID); err != nil { - return nil, err + return nil, mapError(err) } result[chatID] = append(result[chatID], userID) } - return result, rows.Err() + return result, mapError(rows.Err()) } var _ domain.ChatRepository = (*ChatRepo)(nil) diff --git a/backend/internal/storage/postgres/session.go b/backend/internal/storage/postgres/session.go index fa983aa0..430a9e6f 100644 --- a/backend/internal/storage/postgres/session.go +++ b/backend/internal/storage/postgres/session.go @@ -30,7 +30,7 @@ func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error { Value: "", } } - return err + return mapError(err) } return nil } @@ -53,7 +53,7 @@ func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*do func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error { const q = `DELETE FROM sessions WHERE token_hash = $1` _, err := r.pool.Exec(ctx, q, tokenHash) - return err + return mapError(err) } var _ domain.SessionRepository = (*SessionRepo)(nil) diff --git a/backend/internal/storage/postgres/user.go b/backend/internal/storage/postgres/user.go index 804b9552..418f35a6 100644 --- a/backend/internal/storage/postgres/user.go +++ b/backend/internal/storage/postgres/user.go @@ -38,7 +38,7 @@ func (r *UserRepo) Create(ctx context.Context, user *domain.User) error { Message: "нарушено ограничение целостности", } } - return err + return mapError(err) } return nil } -- 2.54.0 From 00d3c0feed23c8c691af6e293eb8f9edb07c127b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 10:08:53 +0300 Subject: [PATCH 31/61] feat(handler): add AuthHandler.RevokeCurrent --- backend/internal/httpapi/handler/auth.go | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/backend/internal/httpapi/handler/auth.go b/backend/internal/httpapi/handler/auth.go index 38bd22b8..b06a8727 100644 --- a/backend/internal/httpapi/handler/auth.go +++ b/backend/internal/httpapi/handler/auth.go @@ -9,6 +9,7 @@ import ( "high-loud-apps-labs/internal/domain" "high-loud-apps-labs/internal/httpapi/dto" + "high-loud-apps-labs/internal/httpapi/middleware" "high-loud-apps-labs/internal/service" ) @@ -36,6 +37,23 @@ func (h *AuthHandler) CreateSession(c *gin.Context) { c.JSON(http.StatusCreated, dto.SessionResponseFromDomain(session, token, user)) } +// RevokeCurrent отзывает текущую сессию. Токен уже проверен BearerAuth, +// поэтому здесь его достаточно передать в SessionService. +func (h *AuthHandler) RevokeCurrent(c *gin.Context) { + token := middleware.CurrentToken(c) + if token == "" { + respondError(c, &domain.UnauthorizedError{Reason: "нет токена"}) + return + } + + if err := h.sessions.Revoke(c.Request.Context(), token); err != nil { + respondError(c, err) + return + } + + c.Status(http.StatusNoContent) +} + // parseBasicAuth читает Authorization: Basic base64(username:password). func parseBasicAuth(c *gin.Context) (string, string, error) { const prefix = "Basic " -- 2.54.0 From c3492128b5e440aaa7a10d893a170dac82f75ab3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 10:36:02 +0300 Subject: [PATCH 32/61] feat(router): expose /auth/sessions endpoints --- backend/internal/httpapi/router.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/backend/internal/httpapi/router.go b/backend/internal/httpapi/router.go index 48a78a76..d45c9362 100644 --- a/backend/internal/httpapi/router.go +++ b/backend/internal/httpapi/router.go @@ -12,6 +12,7 @@ type Handlers struct { User *handler.UserHandler Chat *handler.ChatHandler Message *handler.MessageHandler + Auth *handler.AuthHandler } func NewRouter(h Handlers, auth gin.HandlerFunc) *gin.Engine { @@ -28,11 +29,14 @@ func NewRouter(h Handlers, auth gin.HandlerFunc) *gin.Engine { api := r.Group("/api/v1") { api.POST("/users", h.User.Create) + api.POST("/auth/sessions", h.Auth.CreateSession) } protected := api.Group("") protected.Use(auth) { + protected.DELETE("/auth/sessions/current", h.Auth.RevokeCurrent) + protected.GET("/users/me", h.User.Current) protected.POST("/chats", h.Chat.Create) protected.GET("/chats", h.Chat.List) -- 2.54.0 From fe11f5b83676b93a8f2f9438f856339e35f717e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 11:28:24 +0300 Subject: [PATCH 33/61] feat(config): load configuration from env and secrets files --- backend/internal/config/config.go | 75 +++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 backend/internal/config/config.go diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go new file mode 100644 index 00000000..2b53320b --- /dev/null +++ b/backend/internal/config/config.go @@ -0,0 +1,75 @@ +package config + +import ( + "fmt" + "os" + "strconv" + "strings" + "time" +) + +type Config struct { + Host string + Port string + DatabaseURL string + SessionTTL time.Duration +} + +func Load() (*Config, error) { + dsn, err := readSecret("DATABASE_URL_FILE", "DATABASE_URL") + if err != nil { + return nil, fmt.Errorf("database url: %w", err) + } + + ttlSeconds, err := readInt("SESSION_TTL_SECONDS", 3600) + if err != nil { + return nil, fmt.Errorf("SESSION_TTL_SECONDS: %w", err) + } + if ttlSeconds <= 0 { + return nil, fmt.Errorf("SESSION_TTL_SECONDS должен быть положительным") + } + + return &Config{ + Host: getenv("APP_HOST", "0.0.0.0"), + Port: getenv("APP_PORT", "8080"), + DatabaseURL: dsn, + SessionTTL: time.Duration(ttlSeconds) * time.Second, + }, nil +} + +func getenv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} + +func readInt(key string, def int) (int, error) { + v := os.Getenv(key) + if v == "" { + return def, nil + } + n, err := strconv.Atoi(v) + if err != nil { + return 0, fmt.Errorf("не целое число: %q", v) + } + return n, nil +} + +func readSecret(fileEnv, envKey string) (string, error) { + if path := os.Getenv(fileEnv); path != "" { + b, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("чтение %s=%s: %w", fileEnv, path, err) + } + s := strings.TrimSpace(string(b)) + if s == "" { + return "", fmt.Errorf("файл %s пуст", path) + } + return s, nil + } + if v := os.Getenv(envKey); v != "" { + return v, nil + } + return "", fmt.Errorf("не задан %s или %s", fileEnv, envKey) +} -- 2.54.0 From 83415aec3641533aec7f3f8348dfa9048664e8d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 11:59:55 +0300 Subject: [PATCH 34/61] feat(main): wire postgres, sessions and BearerAuth --- backend/cmd/server/main.go | 45 +++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 13 deletions(-) diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index 515d7165..4846e9a7 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -10,21 +10,46 @@ import ( "syscall" "time" + "high-loud-apps-labs/internal/config" "high-loud-apps-labs/internal/httpapi" "high-loud-apps-labs/internal/httpapi/handler" "high-loud-apps-labs/internal/httpapi/middleware" "high-loud-apps-labs/internal/service" - "high-loud-apps-labs/internal/storage/memory" + "high-loud-apps-labs/internal/storage/postgres" ) func main() { - addr := getenv("APP_HOST", "0.0.0.0") + ":" + getenv("APP_PORT", "8080") + cfg, err := config.Load() + if err != nil { + log.Fatalf("конфигурация: %v", err) + } - store := memory.New() + addr := cfg.Host + ":" + cfg.Port + + ctx := context.Background() + pool, err := postgres.Connect(ctx, postgres.Config{ + URL: cfg.DatabaseURL, + MaxConns: 10, + MinConns: 1, + MaxConnLifetime: time.Hour, + MaxConnIdleTime: 30 * time.Minute, + ConnectTimeout: 5 * time.Second, + }) + if err != nil { + log.Fatalf("БД: %v", err) + } + defer pool.Close() + + if err := postgres.RunMigrations(ctx, pool); err != nil { + log.Fatalf("миграции: %v", err) + } + + store := postgres.New(pool) hasher := service.NewArgon2idHasher() userSvc := service.NewUserService(store.Users(), hasher) + sessionSvc := service.NewSessionService(store.Users(), store.Sessions(), hasher, cfg.SessionTTL) chatSvc := service.NewChatService(store.Chats(), store.Users()) messageSvc := service.NewMessageService(store.Messages(), store.Chats()) @@ -34,8 +59,9 @@ func main() { User: handler.NewUserHandler(userSvc), Chat: handler.NewChatHandler(chatSvc), Message: handler.NewMessageHandler(messageSvc), + Auth: handler.NewAuthHandler(sessionSvc), }, - middleware.Auth(store.Users()), + middleware.BearerAuth(sessionSvc), ) srv := &http.Server{ @@ -55,17 +81,10 @@ func main() { <-quit log.Println("Получен сигнал завершения, останавливаем сервер...") - ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() - if err := srv.Shutdown(ctx); err != nil { + if err := srv.Shutdown(shutdownCtx); err != nil { log.Fatalf("Ошибка при остановке: %v", err) } log.Println("Сервер остановлен") } - -func getenv(key, def string) string { - if v := os.Getenv(key); v != "" { - return v - } - return def -} -- 2.54.0 From b26b2cf0725b7e3e9a14d86d376d433e1cb792cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 12:40:55 +0300 Subject: [PATCH 35/61] chore(infra): add compose stack and restart hook --- compose.yaml | 62 ++++++++++++++++++++++++++++++++++++++++++++++ scripts/restart.sh | 39 +++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+) create mode 100644 compose.yaml create mode 100644 scripts/restart.sh diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..908e98de --- /dev/null +++ b/compose.yaml @@ -0,0 +1,62 @@ +name: mtusi-messenger-lab2 + +services: + postgres: + image: postgres:16.4-alpine + restart: unless-stopped + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_DB: messenger + secrets: + - postgres_password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 5s + networks: + - internal + + api: + build: + context: . + dockerfile: Dockerfile + image: mtusi-messenger-api:lab2 + restart: unless-stopped + ports: + - "8080:8080" + environment: + APP_HOST: "0.0.0.0" + APP_PORT: "8080" + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_TTL_SECONDS: "3600" + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + healthcheck: + test: ["CMD-SHELL", "wget -q -O - http://127.0.0.1:8080/health/ready >/dev/null || exit 1"] + interval: 10s + timeout: 3s + retries: 5 + start_period: 15s + networks: + - internal + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + +volumes: + postgres_data: + +networks: + internal: + driver: bridge \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..611a1b68 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,39 @@ +#!/bin/sh +set -eu + +# Перезапускает API и все используемые хранилища, сохраняя volumes и данные. +# Не удаляет volumes, не пересоздаёт схему, не сидит данные заново. +# Возвращает 0 только после фактической остановки и запуска контейнеров. + +cd "$(dirname "$0")/.." + +COMPOSE="docker compose" +if ! $COMPOSE version >/dev/null 2>&1; then + COMPOSE="docker-compose" +fi + +if [ ! -f .env ]; then + : > .env +fi + +echo "[restart] останавливаем api и postgres" >&2 +$COMPOSE --env-file .env stop api postgres + +echo "[restart] запускаем postgres и ждём healthy" >&2 +$COMPOSE --env-file .env start postgres + +i=0 +until [ "$($COMPOSE ps -q postgres | xargs -r docker inspect -f '{{.State.Health.Status}}' 2>/dev/null)" = "healthy" ]; do + i=$((i + 1)) + if [ "$i" -gt 60 ]; then + echo "[restart] postgres не стал healthy за 60 секунд" >&2 + exit 1 + fi + sleep 1 +done + +echo "[restart] запускаем api" >&2 +$COMPOSE --env-file .env start api + +echo "[restart] готово" >&2 +exit 0 \ No newline at end of file -- 2.54.0 From 42859d90a3235e05e2059d88ff34c4396c60fcc1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 12:42:55 +0300 Subject: [PATCH 36/61] chore(deps):update dependecies --- backend/go.mod | 10 ++++++++++ backend/go.sum | 41 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/backend/go.mod b/backend/go.mod index 8188c5cd..3850b0e7 100644 --- a/backend/go.mod +++ b/backend/go.mod @@ -5,6 +5,9 @@ go 1.26.1 require ( github.com/gin-gonic/gin v1.12.0 github.com/google/uuid v1.6.0 + github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6 + github.com/jackc/pgx/v5 v5.7.1 + github.com/pressly/goose/v3 v3.22.1 golang.org/x/crypto v0.57.0 ) @@ -20,20 +23,27 @@ require ( github.com/go-playground/validator/v10 v10.30.1 // indirect github.com/goccy/go-json v0.10.5 // indirect github.com/goccy/go-yaml v1.19.2 // 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/json-iterator/go v1.1.12 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect github.com/leodido/go-urn v1.4.0 // indirect github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mfridman/interpolate v0.0.2 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/quic-go/qpack v0.6.0 // indirect github.com/quic-go/quic-go v0.59.0 // indirect + github.com/sethvargo/go-retry v0.3.0 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/ugorji/go/codec v1.3.1 // indirect go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect + go.uber.org/multierr v1.11.0 // indirect golang.org/x/arch v0.22.0 // indirect golang.org/x/net v0.58.0 // 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.10 // indirect diff --git a/backend/go.sum b/backend/go.sum index ef696d5b..c551e798 100644 --- a/backend/go.sum +++ b/backend/go.sum @@ -9,6 +9,8 @@ github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gE 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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw= github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w= @@ -32,6 +34,18 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= 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/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6 h1:D/V0gu4zQ3cL2WKeVNVM4r2gLxGGf6McLwgXzRTo2RQ= +github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6/go.mod h1:a/s9Lp5W7n/DD0VrVoyJ00FbP2ytTPDVOivvn2bMlds= +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.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs= +github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA= +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/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= @@ -40,24 +54,35 @@ github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY= +github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= +github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= 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/pressly/goose/v3 v3.22.1 h1:2zICEfr1O3yTP9BRZMGPj7qFxQ+ik6yeo+z1LMuioLc= +github.com/pressly/goose/v3 v3.22.1/go.mod h1:xtMpbstWyCpyH+0cxLTMCENWBG+0CSxvTsXhW95d5eo= github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII= github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw= github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE= +github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= 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.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= @@ -72,12 +97,16 @@ go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI= golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= 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.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= @@ -89,3 +118,15 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8 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= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= +modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= +modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= +modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= +modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= +modernc.org/sqlite v1.33.0 h1:WWkA/T2G17okiLGgKAj4/RMIvgyMT19yQ038160IeYk= +modernc.org/sqlite v1.33.0/go.mod h1:9uQ9hF/pCZoYZK73D/ud5Z7cIRIILSZI8NdIemVMTX8= +modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= +modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= +modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= +modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= -- 2.54.0 From 5a3f6114a4d5c33b3b92c28546cbe0f411713603 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 13:08:24 +0300 Subject: [PATCH 37/61] feat(config): SESSION_STORE and CACHE_URL --- backend/go.mod | 3 ++ backend/go.sum | 6 ++++ backend/internal/config/config.go | 48 +++++++++++++++++++++++-------- 3 files changed, 45 insertions(+), 12 deletions(-) diff --git a/backend/go.mod b/backend/go.mod index 3850b0e7..12d34e9e 100644 --- a/backend/go.mod +++ b/backend/go.mod @@ -15,6 +15,7 @@ require ( github.com/bytedance/gopkg v0.1.3 // indirect github.com/bytedance/sonic v1.15.0 // indirect github.com/bytedance/sonic/loader v0.5.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cloudwego/base64x v0.1.6 // indirect github.com/gabriel-vasile/mimetype v1.4.12 // indirect github.com/gin-contrib/sse v1.1.0 // indirect @@ -36,10 +37,12 @@ require ( github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/quic-go/qpack v0.6.0 // indirect github.com/quic-go/quic-go v0.59.0 // indirect + github.com/redis/go-redis/v9 v9.22.0 // indirect github.com/sethvargo/go-retry v0.3.0 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/ugorji/go/codec v1.3.1 // indirect go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect + go.uber.org/atomic v1.11.0 // indirect go.uber.org/multierr v1.11.0 // indirect golang.org/x/arch v0.22.0 // indirect golang.org/x/net v0.58.0 // indirect diff --git a/backend/go.sum b/backend/go.sum index c551e798..ae83588c 100644 --- a/backend/go.sum +++ b/backend/go.sum @@ -4,6 +4,8 @@ github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uS github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k= github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE= github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo= +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/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -73,6 +75,8 @@ github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII= github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw= github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU= +github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0= +github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE= @@ -95,6 +99,8 @@ github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4= go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE= go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go index 2b53320b..ef6fda7a 100644 --- a/backend/internal/config/config.go +++ b/backend/internal/config/config.go @@ -9,10 +9,12 @@ import ( ) type Config struct { - Host string - Port string - DatabaseURL string - SessionTTL time.Duration + Host string + Port string + DatabaseURL string + SessionStore string + CacheURL string + SessionTTL time.Duration } func Load() (*Config, error) { @@ -21,6 +23,11 @@ func Load() (*Config, error) { return nil, fmt.Errorf("database url: %w", err) } + cacheURL, err := readSecretOptional("CACHE_URL_FILE", "CACHE_URL") + if err != nil { + return nil, fmt.Errorf("cache url: %w", err) + } + ttlSeconds, err := readInt("SESSION_TTL_SECONDS", 3600) if err != nil { return nil, fmt.Errorf("SESSION_TTL_SECONDS: %w", err) @@ -29,11 +36,20 @@ func Load() (*Config, error) { return nil, fmt.Errorf("SESSION_TTL_SECONDS должен быть положительным") } + store := strings.ToLower(getenv("SESSION_STORE", "postgres")) + switch store { + case "postgres", "redis", "valkey": + default: + return nil, fmt.Errorf("SESSION_STORE=%q не поддерживается", store) + } + return &Config{ - Host: getenv("APP_HOST", "0.0.0.0"), - Port: getenv("APP_PORT", "8080"), - DatabaseURL: dsn, - SessionTTL: time.Duration(ttlSeconds) * time.Second, + Host: getenv("APP_HOST", "0.0.0.0"), + Port: getenv("APP_PORT", "8080"), + DatabaseURL: dsn, + SessionStore: store, + CacheURL: cacheURL, + SessionTTL: time.Duration(ttlSeconds) * time.Second, }, nil } @@ -57,6 +73,17 @@ func readInt(key string, def int) (int, error) { } func readSecret(fileEnv, envKey string) (string, error) { + v, err := readSecretOptional(fileEnv, envKey) + if err != nil { + return "", err + } + if v == "" { + return "", fmt.Errorf("не задан %s или %s", fileEnv, envKey) + } + return v, nil +} + +func readSecretOptional(fileEnv, envKey string) (string, error) { if path := os.Getenv(fileEnv); path != "" { b, err := os.ReadFile(path) if err != nil { @@ -68,8 +95,5 @@ func readSecret(fileEnv, envKey string) (string, error) { } return s, nil } - if v := os.Getenv(envKey); v != "" { - return v, nil - } - return "", fmt.Errorf("не задан %s или %s", fileEnv, envKey) + return os.Getenv(envKey), nil } -- 2.54.0 From 812efa67bb94bf3075bc5d827ecd866d4a99713c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 14:02:55 +0300 Subject: [PATCH 38/61] feat(redis): session repository with native TTL and main connection --- backend/cmd/server/main.go | 34 ++++++++-- backend/internal/storage/redis/client.go | 32 +++++++++ backend/internal/storage/redis/errors.go | 26 ++++++++ backend/internal/storage/redis/session.go | 80 +++++++++++++++++++++++ 4 files changed, 166 insertions(+), 6 deletions(-) create mode 100644 backend/internal/storage/redis/client.go create mode 100644 backend/internal/storage/redis/errors.go create mode 100644 backend/internal/storage/redis/session.go diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index 4846e9a7..30f75b98 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -7,15 +7,18 @@ import ( "net/http" "os" "os/signal" + "strings" "syscall" "time" "high-loud-apps-labs/internal/config" + "high-loud-apps-labs/internal/domain" "high-loud-apps-labs/internal/httpapi" "high-loud-apps-labs/internal/httpapi/handler" "high-loud-apps-labs/internal/httpapi/middleware" "high-loud-apps-labs/internal/service" "high-loud-apps-labs/internal/storage/postgres" + redisstore "high-loud-apps-labs/internal/storage/redis" ) func main() { @@ -46,10 +49,13 @@ func main() { store := postgres.New(pool) + sessionRepo, closeSession := newSessionRepo(cfg, store) + defer closeSession() + hasher := service.NewArgon2idHasher() userSvc := service.NewUserService(store.Users(), hasher) - sessionSvc := service.NewSessionService(store.Users(), store.Sessions(), hasher, cfg.SessionTTL) + sessionSvc := service.NewSessionService(store.Users(), sessionRepo, hasher, cfg.SessionTTL) chatSvc := service.NewChatService(store.Chats(), store.Users()) messageSvc := service.NewMessageService(store.Messages(), store.Chats()) @@ -64,13 +70,10 @@ func main() { middleware.BearerAuth(sessionSvc), ) - srv := &http.Server{ - Addr: addr, - Handler: router, - } + srv := &http.Server{Addr: addr, Handler: router} go func() { - log.Printf("Запускаем на %s", addr) + log.Printf("Запускаем на %s (SESSION_STORE=%s)", addr, cfg.SessionStore) if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { log.Fatalf("Ошибка запуска: %v", err) } @@ -88,3 +91,22 @@ func main() { } log.Println("Сервер остановлен") } + +func newSessionRepo(cfg *config.Config, store *postgres.Storage) (domain.SessionRepository, func()) { + switch strings.ToLower(cfg.SessionStore) { + case "", "postgres": + return store.Sessions(), func() {} + case "redis", "valkey": + if cfg.CacheURL == "" { + log.Fatalf("SESSION_STORE=%s требует CACHE_URL_FILE или CACHE_URL", cfg.SessionStore) + } + client, err := redisstore.NewClient(cfg.CacheURL) + if err != nil { + log.Fatalf("redis: %v", err) + } + return redisstore.NewSessionRepo(client), func() { _ = client.Close() } + default: + log.Fatalf("SESSION_STORE=%q не поддерживается", cfg.SessionStore) + return nil, nil + } +} diff --git a/backend/internal/storage/redis/client.go b/backend/internal/storage/redis/client.go new file mode 100644 index 00000000..9680e60a --- /dev/null +++ b/backend/internal/storage/redis/client.go @@ -0,0 +1,32 @@ +package redis + +import ( + "context" + "fmt" + "time" + + "github.com/redis/go-redis/v9" +) + +func NewClient(url string) (*redis.Client, error) { + opt, err := redis.ParseURL(url) + if err != nil { + return nil, fmt.Errorf("разбор URL: %w", err) + } + + opt.DialTimeout = 5 * time.Second + opt.ReadTimeout = 3 * time.Second + opt.WriteTimeout = 3 * time.Second + opt.MaxRetries = 2 + opt.PoolSize = 10 + + client := redis.NewClient(opt) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := client.Ping(ctx).Err(); err != nil { + _ = client.Close() + return nil, fmt.Errorf("ping: %w", err) + } + return client, nil +} diff --git a/backend/internal/storage/redis/errors.go b/backend/internal/storage/redis/errors.go new file mode 100644 index 00000000..c2cc4355 --- /dev/null +++ b/backend/internal/storage/redis/errors.go @@ -0,0 +1,26 @@ +package redis + +import ( + "context" + "errors" + + "high-loud-apps-labs/internal/domain" +) + +type coded interface { + Code() domain.ErrorCode +} + +func mapError(err error) error { + if err == nil { + return nil + } + var c coded + if errors.As(err, &c) { + return err + } + if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { + return err + } + return &domain.UnavailableError{Reason: err.Error()} +} diff --git a/backend/internal/storage/redis/session.go b/backend/internal/storage/redis/session.go new file mode 100644 index 00000000..0aecfd59 --- /dev/null +++ b/backend/internal/storage/redis/session.go @@ -0,0 +1,80 @@ +package redis + +import ( + "context" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "time" + + "github.com/redis/go-redis/v9" + + "high-loud-apps-labs/internal/domain" +) + +const sessionKeyPrefix = "session:" + +type SessionRepo struct { + client *redis.Client +} + +func NewSessionRepo(client *redis.Client) *SessionRepo { + return &SessionRepo{client: client} +} + +type sessionValue struct { + UserID string `json:"user_id"` + ExpiresAt time.Time `json:"expires_at"` + CreatedAt time.Time `json:"created_at"` +} + +func (r *SessionRepo) key(tokenHash []byte) string { + return sessionKeyPrefix + hex.EncodeToString(tokenHash) +} + +func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error { + ttl := time.Until(s.ExpiresAt) + if ttl <= 0 { + return nil + } + + data, err := json.Marshal(sessionValue{ + UserID: s.UserID, + ExpiresAt: s.ExpiresAt.UTC(), + CreatedAt: s.CreatedAt.UTC(), + }) + if err != nil { + return fmt.Errorf("сериализация сессии: %w", err) + } + + return mapError(r.client.Set(ctx, r.key(s.TokenHash), data, ttl).Err()) +} + +func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*domain.Session, error) { + data, err := r.client.Get(ctx, r.key(tokenHash)).Bytes() + if err != nil { + if errors.Is(err, redis.Nil) { + return nil, &domain.NotFoundError{Entity: "session"} + } + return nil, mapError(err) + } + + var sv sessionValue + if err := json.Unmarshal(data, &sv); err != nil { + return nil, fmt.Errorf("разбор сессии: %w", err) + } + + return &domain.Session{ + TokenHash: tokenHash, + UserID: sv.UserID, + ExpiresAt: sv.ExpiresAt, + CreatedAt: sv.CreatedAt, + }, nil +} + +func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error { + return mapError(r.client.Del(ctx, r.key(tokenHash)).Err()) +} + +var _ domain.SessionRepository = (*SessionRepo)(nil) -- 2.54.0 From eaf04c4769d3b031e371a297a097777b3e63e8e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 14:42:55 +0300 Subject: [PATCH 39/61] chore(infra): redis service with AOF persistence --- compose.yaml | 30 ++++++++++++++++++++++++++++++ scripts/restart.cmd | 5 +++++ scripts/restart.sh | 32 +++++++++++++++++++------------- 3 files changed, 54 insertions(+), 13 deletions(-) create mode 100644 scripts/restart.cmd diff --git a/compose.yaml b/compose.yaml index 908e98de..7ff31ced 100644 --- a/compose.yaml +++ b/compose.yaml @@ -21,6 +21,28 @@ services: networks: - internal + redis: + image: redis:7.4-alpine + restart: unless-stopped + command: + - redis-server + - --appendonly + - "yes" + - --appendfsync + - everysec + - --save + - "60 1000" + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 5s + networks: + - internal + api: build: context: . @@ -33,12 +55,17 @@ services: APP_HOST: "0.0.0.0" APP_PORT: "8080" DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + SESSION_STORE: "redis" SESSION_TTL_SECONDS: "3600" secrets: - database_url + - cache_url depends_on: postgres: condition: service_healthy + redis: + condition: service_healthy healthcheck: test: ["CMD-SHELL", "wget -q -O - http://127.0.0.1:8080/health/ready >/dev/null || exit 1"] interval: 10s @@ -53,9 +80,12 @@ secrets: file: ./secrets/postgres_password database_url: file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url volumes: postgres_data: + redis_data: networks: internal: diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..85681369 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,5 @@ +@echo off +setlocal +set SCRIPT_DIR=%~dp0 +bash "%SCRIPT_DIR%restart.sh" +exit /b %ERRORLEVEL% \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh index 611a1b68..9e50da9b 100644 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -3,7 +3,6 @@ set -eu # Перезапускает API и все используемые хранилища, сохраняя volumes и данные. # Не удаляет volumes, не пересоздаёт схему, не сидит данные заново. -# Возвращает 0 только после фактической остановки и запуска контейнеров. cd "$(dirname "$0")/.." @@ -16,21 +15,28 @@ if [ ! -f .env ]; then : > .env fi -echo "[restart] останавливаем api и postgres" >&2 -$COMPOSE --env-file .env stop api postgres +echo "[restart] останавливаем api, postgres, redis" >&2 +$COMPOSE --env-file .env stop api postgres redis -echo "[restart] запускаем postgres и ждём healthy" >&2 +echo "[restart] запускаем postgres" >&2 $COMPOSE --env-file .env start postgres +wait_healthy() { + service="$1" + i=0 + until [ "$($COMPOSE ps -q "$service" | xargs -r docker inspect -f '{{.State.Health.Status}}' 2>/dev/null)" = "healthy" ]; do + i=$((i + 1)) + if [ "$i" -gt 60 ]; then + echo "[restart] $service не стал healthy за 60 секунд" >&2 + exit 1 + fi + sleep 1 + done +} +wait_healthy postgres -i=0 -until [ "$($COMPOSE ps -q postgres | xargs -r docker inspect -f '{{.State.Health.Status}}' 2>/dev/null)" = "healthy" ]; do - i=$((i + 1)) - if [ "$i" -gt 60 ]; then - echo "[restart] postgres не стал healthy за 60 секунд" >&2 - exit 1 - fi - sleep 1 -done +echo "[restart] запускаем redis" >&2 +$COMPOSE --env-file .env start redis +wait_healthy redis echo "[restart] запускаем api" >&2 $COMPOSE --env-file .env start api -- 2.54.0 From 46181bb404679ffdd8f1fa58cb30716e30da5ba1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 15:10:03 +0300 Subject: [PATCH 40/61] fix(health): readiness pings postgres and redis instead of returning 200 --- backend/cmd/server/main.go | 22 +++++++++++++------ backend/internal/httpapi/handler/health.go | 25 +++++++++++++++++++--- 2 files changed, 38 insertions(+), 9 deletions(-) diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index 30f75b98..388a96e1 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -49,7 +49,7 @@ func main() { store := postgres.New(pool) - sessionRepo, closeSession := newSessionRepo(cfg, store) + sessionRepo, cachePing, closeSession := newSessionRepo(cfg, store) defer closeSession() hasher := service.NewArgon2idHasher() @@ -59,9 +59,16 @@ func main() { chatSvc := service.NewChatService(store.Chats(), store.Users()) messageSvc := service.NewMessageService(store.Messages(), store.Chats()) + healthChecks := []handler.HealthCheck{ + func(ctx context.Context) error { return pool.Ping(ctx) }, + } + if cachePing != nil { + healthChecks = append(healthChecks, cachePing) + } + router := httpapi.NewRouter( httpapi.Handlers{ - Health: handler.NewHealthHandler(), + Health: handler.NewHealthHandler(healthChecks...), User: handler.NewUserHandler(userSvc), Chat: handler.NewChatHandler(chatSvc), Message: handler.NewMessageHandler(messageSvc), @@ -92,10 +99,10 @@ func main() { log.Println("Сервер остановлен") } -func newSessionRepo(cfg *config.Config, store *postgres.Storage) (domain.SessionRepository, func()) { +func newSessionRepo(cfg *config.Config, store *postgres.Storage) (domain.SessionRepository, handler.HealthCheck, func()) { switch strings.ToLower(cfg.SessionStore) { case "", "postgres": - return store.Sessions(), func() {} + return store.Sessions(), nil, func() {} case "redis", "valkey": if cfg.CacheURL == "" { log.Fatalf("SESSION_STORE=%s требует CACHE_URL_FILE или CACHE_URL", cfg.SessionStore) @@ -104,9 +111,12 @@ func newSessionRepo(cfg *config.Config, store *postgres.Storage) (domain.Session if err != nil { log.Fatalf("redis: %v", err) } - return redisstore.NewSessionRepo(client), func() { _ = client.Close() } + ping := func(ctx context.Context) error { + return client.Ping(ctx).Err() + } + return redisstore.NewSessionRepo(client), ping, func() { _ = client.Close() } default: log.Fatalf("SESSION_STORE=%q не поддерживается", cfg.SessionStore) - return nil, nil + return nil, nil, nil } } diff --git a/backend/internal/httpapi/handler/health.go b/backend/internal/httpapi/handler/health.go index fc4ee1ea..4c231ab6 100644 --- a/backend/internal/httpapi/handler/health.go +++ b/backend/internal/httpapi/handler/health.go @@ -1,17 +1,24 @@ package handler import ( + "context" "net/http" + "time" "github.com/gin-gonic/gin" + "high-loud-apps-labs/internal/domain" "high-loud-apps-labs/internal/httpapi/dto" ) -type HealthHandler struct{} +type HealthCheck func(ctx context.Context) error -func NewHealthHandler() *HealthHandler { - return &HealthHandler{} +type HealthHandler struct { + checks []HealthCheck +} + +func NewHealthHandler(checks ...HealthCheck) *HealthHandler { + return &HealthHandler{checks: checks} } func (h *HealthHandler) Live(c *gin.Context) { @@ -19,5 +26,17 @@ func (h *HealthHandler) Live(c *gin.Context) { } func (h *HealthHandler) Ready(c *gin.Context) { + ctx, cancel := context.WithTimeout(c.Request.Context(), 2*time.Second) + defer cancel() + + for _, check := range h.checks { + if check == nil { + continue + } + if err := check(ctx); err != nil { + respondError(c, &domain.UnavailableError{Reason: "зависимость недоступна"}) + return + } + } c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"}) } -- 2.54.0 From e0723c0e988e250a965514c57b0c45850be0b0ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 15:24:11 +0300 Subject: [PATCH 41/61] fix(redis): shorten dial/read/write timeouts and cap retries --- backend/internal/storage/redis/client.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/backend/internal/storage/redis/client.go b/backend/internal/storage/redis/client.go index 9680e60a..0da66143 100644 --- a/backend/internal/storage/redis/client.go +++ b/backend/internal/storage/redis/client.go @@ -14,15 +14,16 @@ func NewClient(url string) (*redis.Client, error) { return nil, fmt.Errorf("разбор URL: %w", err) } - opt.DialTimeout = 5 * time.Second - opt.ReadTimeout = 3 * time.Second - opt.WriteTimeout = 3 * time.Second - opt.MaxRetries = 2 + opt.DialTimeout = 700 * time.Millisecond + opt.ReadTimeout = 700 * time.Millisecond + opt.WriteTimeout = 700 * time.Millisecond + opt.MaxRetries = 1 opt.PoolSize = 10 + opt.ConnMaxIdleTime = time.Minute client := redis.NewClient(opt) - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() if err := client.Ping(ctx).Err(); err != nil { _ = client.Close() -- 2.54.0 From b40ac615b3b6b4ac3ea5933b9b1c317498a3a59c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 15:38:47 +0300 Subject: [PATCH 42/61] fix(storage): map context deadline exceeded to unavailable error --- backend/internal/storage/postgres/errors.go | 7 +++++-- backend/internal/storage/redis/errors.go | 9 +++++++-- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/backend/internal/storage/postgres/errors.go b/backend/internal/storage/postgres/errors.go index a3a4de3c..63861286 100644 --- a/backend/internal/storage/postgres/errors.go +++ b/backend/internal/storage/postgres/errors.go @@ -27,8 +27,11 @@ func mapError(err error) error { if errors.Is(err, pgx.ErrNoRows) { return err } - if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { - return err + if errors.Is(err, context.DeadlineExceeded) { + return &domain.UnavailableError{Reason: "превышено время ожидания БД"} + } + if errors.Is(err, context.Canceled) { + return &domain.UnavailableError{Reason: "запрос отменён"} } return &domain.UnavailableError{Reason: err.Error()} } diff --git a/backend/internal/storage/redis/errors.go b/backend/internal/storage/redis/errors.go index c2cc4355..55e34226 100644 --- a/backend/internal/storage/redis/errors.go +++ b/backend/internal/storage/redis/errors.go @@ -11,6 +11,8 @@ type coded interface { Code() domain.ErrorCode } +// mapError переводит ошибки драйвера в доменные. +// Любая недоступность redis (dial/read/write/context) → UnavailableError (503). func mapError(err error) error { if err == nil { return nil @@ -19,8 +21,11 @@ func mapError(err error) error { if errors.As(err, &c) { return err } - if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { - return err + if errors.Is(err, context.DeadlineExceeded) { + return &domain.UnavailableError{Reason: "превышено время ожидания redis"} + } + if errors.Is(err, context.Canceled) { + return &domain.UnavailableError{Reason: "запрос отменён"} } return &domain.UnavailableError{Reason: err.Error()} } -- 2.54.0 From 3db2891e4a9386e47647ad4b0a1f8dc5eafd6ad0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 15:53:22 +0300 Subject: [PATCH 43/61] fix(auth): cap session resolve with a three-second context deadline --- backend/internal/httpapi/middleware/bearer.go | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/backend/internal/httpapi/middleware/bearer.go b/backend/internal/httpapi/middleware/bearer.go index 6e04a916..fc904aa2 100644 --- a/backend/internal/httpapi/middleware/bearer.go +++ b/backend/internal/httpapi/middleware/bearer.go @@ -1,7 +1,9 @@ package middleware import ( + "context" "strings" + "time" "github.com/gin-gonic/gin" @@ -10,6 +12,8 @@ import ( "high-loud-apps-labs/internal/service" ) +const authTimeout = 3 * time.Second + // BearerAuth читает Authorization: Bearer , проверяет сессию // через SessionService и кладёт пользователя и токен в контекст. func BearerAuth(sessions *service.SessionService) gin.HandlerFunc { @@ -20,7 +24,10 @@ func BearerAuth(sessions *service.SessionService) gin.HandlerFunc { return } - user, err := sessions.Resolve(c.Request.Context(), token) + ctx, cancel := context.WithTimeout(c.Request.Context(), authTimeout) + defer cancel() + + user, err := sessions.Resolve(ctx, token) if err != nil { abortBearerWithErr(c, err) return @@ -52,7 +59,7 @@ func abortBearer(c *gin.Context, reason string) { // abortBearerWithErr формирует ответ на ошибку аутентификации. // Заголовок WWW-Authenticate: Bearer выставляется только на 401; -// при 503 (недоступность БД) - обычный ответ ошибки без challenge. +// при 503 (недоступность БД/кэша) — обычный ответ ошибки без challenge. func abortBearerWithErr(c *gin.Context, err error) { reqID := GetRequestID(c) status := dto.StatusFromError(err) -- 2.54.0 From c7ca2a338ba95e1726dcdb99b118dc7b7fd62a16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 16:09:15 +0300 Subject: [PATCH 44/61] fix(postgres): tune pool health check period for faster dead-conn eviction --- backend/internal/storage/postgres/db.go | 1 + 1 file changed, 1 insertion(+) diff --git a/backend/internal/storage/postgres/db.go b/backend/internal/storage/postgres/db.go index 875a88c5..ad27e83e 100644 --- a/backend/internal/storage/postgres/db.go +++ b/backend/internal/storage/postgres/db.go @@ -45,6 +45,7 @@ func Connect(ctx context.Context, cfg Config) (*pgxpool.Pool, error) { if cfg.ConnectTimeout > 0 { poolCfg.ConnConfig.ConnectTimeout = cfg.ConnectTimeout } + poolCfg.HealthCheckPeriod = 10 * time.Second pool, err := pgxpool.NewWithConfig(ctx, poolCfg) if err != nil { -- 2.54.0 From effb19289bd847e3292a5322b86ab03df01f2892 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 16:24:40 +0300 Subject: [PATCH 45/61] fix(student-tests): pass user schema when seeding messages --- student-tests/seed_messages.py | 56 ++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 student-tests/seed_messages.py diff --git a/student-tests/seed_messages.py b/student-tests/seed_messages.py new file mode 100644 index 00000000..47bd6081 --- /dev/null +++ b/student-tests/seed_messages.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +"""Заполняет один чат N сообщениями. Надо EXPLAIN.""" +import base64 +import sys +import time +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, arguments, check, run # noqa: E402 + + +def make_user(c, label): + username = f'{label}_{uuid.uuid4().hex[:12]}' + password = 'T3st-' + uuid.uuid4().hex + user = c.call('POST', '/api/v1/users', 201, body={ + 'username': username, 'display_name': label.capitalize(), + 'password': password}, schema='User')['json'] + cred = base64.b64encode(f'{username}:{password}'.encode()).decode() + s = c.call('POST', '/api/v1/auth/sessions', 201, + headers={'Authorization': 'Basic ' + cred}, schema='Session')['json'] + return {'id': user['id'], 'token': s['token']} + + +def main(): + def configure(p): + p.add_argument('--count', type=int, default=10000) + + args = arguments('Сид для EXPLAIN: создаёт count сообщений в новом чате', configure) + check(args.count >= 1 and args.count <= 1_000_000, 'count вне диапазона') + + c = Client(args.base_url, args.ca_file) + alice = make_user(c, 'seed_a') + bob = make_user(c, 'seed_b') + + chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={ + 'title': 'Seed chat', 'member_ids': [alice['id'], bob['id']]}, + schema='Chat')['json'] + + started = time.monotonic() + for i in range(args.count): + c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 201, + actor=alice, body={'text': f'seed message {i}'}, schema='Message') + if (i + 1) % 1000 == 0: + print(f' {i + 1}/{args.count}') + + elapsed = time.monotonic() - started + print(f'seeded {args.count} messages in {elapsed:.1f}s ' + f'({args.count / elapsed:.0f}/s)') + print(f'chat_id={chat["id"]}') + + +if __name__ == '__main__': + run(main) \ No newline at end of file -- 2.54.0 From 9bba9c4b25d25cf55dc0d00cc29b3eb41b06e423 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 16:32:10 +0300 Subject: [PATCH 46/61] test(student-tests): lab2 consolidate negative, concurrency, auth and resilience checks in one commit --- evidence/explain_history.txt | 33 ++++++++++++ student-tests/README.md | 36 +++++++++++-- student-tests/explain_history.sh | 44 +++++++++++++++ student-tests/run_all.py | 10 +++- student-tests/test_auth.py | 81 ++++++++++++++++++++++++++++ student-tests/test_concurrency.py | 5 +- student-tests/test_expiry.py | 46 ++++++++++++++++ student-tests/test_resilience.py | 89 +++++++++++++++++++++++++++++++ 8 files changed, 337 insertions(+), 7 deletions(-) create mode 100644 evidence/explain_history.txt create mode 100644 student-tests/explain_history.sh create mode 100644 student-tests/test_auth.py create mode 100644 student-tests/test_expiry.py create mode 100644 student-tests/test_resilience.py diff --git a/evidence/explain_history.txt b/evidence/explain_history.txt new file mode 100644 index 00000000..8f2a0c0a --- /dev/null +++ b/evidence/explain_history.txt @@ -0,0 +1,33 @@ +# EXPLAIN (ANALYZE, BUFFERS) для истории сообщений +# date: 2026-10-02T11:01:11Z +# chat_id: cf9e8ca9-d08c-41d1-b55f-18c9fba43aec + +## Ключевой запрос пагинации + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..4.38 rows=50 width=73) (actual time=0.021..0.029 rows=50 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..819.43 rows=10000 width=73) (actual time=0.020..0.025 rows=50 loops=1) + Index Cond: (chat_id = 'cf9e8ca9-d08c-41d1-b55f-18c9fba43aec'::uuid) + Buffers: shared hit=3 + Planning: + Buffers: shared hit=111 + Planning Time: 0.694 ms + Execution Time: 0.063 ms +(9 rows) + + +## Индексы таблицы messages + indexname | indexdef +------------------------------+---------------------------------------------------------------------------------------------------- + messages_pkey | CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id) + messages_chat_created_id_idx | CREATE INDEX messages_chat_created_id_idx ON public.messages USING btree (chat_id, created_at, id) +(2 rows) + + +## Оценка размера и количества + estimated_rows | total_size +----------------+------------ + 10222 | 2264 kB +(1 row) + diff --git a/student-tests/README.md b/student-tests/README.md index 0781b12d..7524c0d8 100644 --- a/student-tests/README.md +++ b/student-tests/README.md @@ -1,7 +1,37 @@ # Собственные тесты -Проверки негативных сценариев и конкурентной работы, отдельно от публичных `tests/`. +Проверки негативных сценариев, конкурентной работы, жизненного цикла +сессий и отказов хранилищ. Отдельно от публичных `tests/`. -Запуск (сервер уже должен быть поднят на `localhost:8080`): +Сервер должен быть поднят на `http://localhost:8080`. - python students-tests/run_all.py --base-url http://localhost:8080 +## Быстрый прогон + + python student-tests/run_all.py --base-url http://localhost:8080 + +Запускает `test_cases.py`, `test_concurrency.py`, `test_auth.py`. +Это базовый набор, не требующий особой конфигурации стенда. + +## Отдельные сценарии + + python student-tests/test_expiry.py --base-url http://localhost:8080 + +Требует стенд с `SESSION_TTL_SECONDS=2`. Проверяет, что сессия +перестаёт работать после истечения TTL. Меняй TTL в `compose.yaml`, +перезапускай api и прогоняй. + + python student-tests/test_resilience.py --service redis + python student-tests/test_resilience.py --service postgres + +Требуют запущенного Docker и работающего стенда. Скрипт останавливает +указанный сервис через `docker compose stop`, проверяет, что защищённые +endpoint отдают 503 unavailable (не 401 и не 500), и запускает сервис +обратно. + +## Данные для EXPLAIN + + python student-tests/seed_messages.py --count 10000 + student-tests/explain_history.sh + +`seed_messages.py` печатает `chat_id`; передай его в `explain_history.sh`, +результат сохранится в `evidence/explain_history.txt`. \ No newline at end of file diff --git a/student-tests/explain_history.sh b/student-tests/explain_history.sh new file mode 100644 index 00000000..5f381fd4 --- /dev/null +++ b/student-tests/explain_history.sh @@ -0,0 +1,44 @@ +#!/bin/sh +set -eu + +chat_id="${1:-}" +if [ -z "$chat_id" ]; then + echo "usage: $0 " >&2 + echo "chat_id печатает student-tests/seed_messages.py" >&2 + exit 2 +fi + +cd "$(dirname "$0")/.." +mkdir -p evidence + +{ + echo "# EXPLAIN (ANALYZE, BUFFERS) для истории сообщений" + echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)" + echo "# chat_id: $chat_id" + echo + + echo "## Ключевой запрос пагинации" + docker compose exec -T postgres psql -U messenger -d messenger -c " + EXPLAIN (ANALYZE, BUFFERS) + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = '$chat_id' + ORDER BY created_at, id + LIMIT 50; + " + echo + + echo "## Индексы таблицы messages" + docker compose exec -T postgres psql -U messenger -d messenger -c " + SELECT indexname, indexdef FROM pg_indexes + WHERE tablename = 'messages'; + " + echo + + echo "## Оценка размера и количества" + docker compose exec -T postgres psql -U messenger -d messenger -c " + SELECT reltuples::bigint AS estimated_rows, + pg_size_pretty(pg_total_relation_size('messages')) AS total_size + FROM pg_class WHERE relname = 'messages'; + " +} | tee evidence/explain_history.txt \ No newline at end of file diff --git a/student-tests/run_all.py b/student-tests/run_all.py index e089770d..69f04674 100644 --- a/student-tests/run_all.py +++ b/student-tests/run_all.py @@ -5,14 +5,20 @@ from pathlib import Path ROOT = Path(__file__).resolve().parent +QUICK = ('test_cases.py', 'test_concurrency.py', 'test_auth.py') + def main(): args = sys.argv[1:] - for script in ('test_cases.py', 'test_concurrency.py'): + failed = [] + for script in QUICK: print(f'=== {script} ===') result = subprocess.run([sys.executable, str(ROOT / script), *args]) if result.returncode != 0: - sys.exit(result.returncode) + failed.append(script) + if failed: + print('FAILED:', ', '.join(failed)) + sys.exit(1) print('=== Все тесты прошли ===') diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..5fab75d9 --- /dev/null +++ b/student-tests/test_auth.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +import base64 +import uuid +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, Failure, arguments, check, run # noqa: E402 + + +def register(c, username, password): + c.call('POST', '/api/v1/users', 201, body={ + 'username': username, + 'display_name': 'Auth test', + 'password': password, + }) + + +def login(c, username, password): + cred = base64.b64encode(f'{username}:{password}'.encode()).decode() + r = c.call('POST', '/api/v1/auth/sessions', 201, + headers={'Authorization': 'Basic ' + cred}, schema='Session') + return r['json'] + + +def main(): + args = arguments('Logout и неверные учётные данные') + c = Client(args.base_url, args.ca_file) + + # --- logout отзывает текущую сессию --- + username = 'lo_' + uuid.uuid4().hex[:10] + password = 'T3st-' + uuid.uuid4().hex + register(c, username, password) + session = login(c, username, password) + actor = {'id': session['user']['id'], 'token': session['token']} + + # токен работает + c.call('GET', '/api/v1/users/me', actor=actor, schema='User') + + # отзываем + c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=actor) + + # тот же токен больше не работает + c.call('GET', '/api/v1/users/me', 401, actor=actor) + c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=actor) + + # --- неверный пароль и неизвестный username дают одинаковый 401 --- + wrong = base64.b64encode(f'{username}:wrong-password-123'.encode()).decode() + r_wrong = c.call('POST', '/api/v1/auth/sessions', 401, + headers={'Authorization': 'Basic ' + wrong}) + check('Basic' in r_wrong['headers'].get('WWW-Authenticate', ''), + 'нет WWW-Authenticate: Basic на неверный пароль') + + unknown = base64.b64encode( + f'nobody_{uuid.uuid4().hex[:10]}:any-password-123'.encode()).decode() + r_unknown = c.call('POST', '/api/v1/auth/sessions', 401, + headers={'Authorization': 'Basic ' + unknown}) + + check(r_wrong['json']['error']['code'] == 'unauthorized', + 'неверный пароль: ожидался код unauthorized') + check(r_unknown['json']['error']['code'] == 'unauthorized', + 'неизвестный username: ожидался код unauthorized') + check(r_wrong['json']['error']['message'] == r_unknown['json']['error']['message'], + 'сообщения отличаются: перебор username возможен') + + # --- X-User-Id не даёт доступ в lab2 --- + c.call('GET', '/api/v1/users/me', 401, + headers={'X-User-Id': session['user']['id']}) + + # --- Basic на бизнес-endpoint не проходит --- + good = base64.b64encode(f'{username}:{password}'.encode()).decode() + c.call('GET', '/api/v1/users/me', 401, + headers={'Authorization': 'Basic ' + good}) + + print('PASS: logout, wrong password, X-User-Id и Basic на бизнес-endpoint') + + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py index 9dee97a4..05fd018d 100644 --- a/student-tests/test_concurrency.py +++ b/student-tests/test_concurrency.py @@ -52,14 +52,15 @@ def main(): # --- гонка за username --- username = 'race_' + uuid.uuid4().hex[:8] + password = 'T3st-' + uuid.uuid4().hex + body = {'username': username, 'display_name': 'Race', 'password': password} barrier2 = threading.Barrier(workers) def register(_): local = Client(args.base_url, args.ca_file, timeout=10) barrier2.wait() try: - local.call('POST', '/api/v1/users', 201, - body={'username': username, 'display_name': 'Race'}) + local.call('POST', '/api/v1/users', 201, body=body) return 'ok' except Failure: return 'conflict' diff --git a/student-tests/test_expiry.py b/student-tests/test_expiry.py new file mode 100644 index 00000000..b79aa2ae --- /dev/null +++ b/student-tests/test_expiry.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +import base64 +import time +import uuid +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, arguments, check, run # noqa: E402 + + +def main(): + args = arguments('Истечение сессии. Требует SESSION_TTL_SECONDS=2') + c = Client(args.base_url, args.ca_file) + + username = 'exp_' + uuid.uuid4().hex[:10] + password = 'T3st-' + uuid.uuid4().hex + c.call('POST', '/api/v1/users', 201, body={ + 'username': username, 'display_name': 'Exp', 'password': password}) + + cred = base64.b64encode(f'{username}:{password}'.encode()).decode() + s = c.call('POST', '/api/v1/auth/sessions', 201, + headers={'Authorization': 'Basic ' + cred}, schema='Session')['json'] + actor = {'id': s['user']['id'], 'token': s['token']} + + # сразу после логина — работает + c.call('GET', '/api/v1/users/me', actor=actor, schema='User') + + # ждём больше TTL. Если TTL не 2, тест упадёт с понятным сообщением + # (см. проверку ниже по факту отказа). + time.sleep(3.5) + + # ожидаем 401 с Bearer challenge + r = c.call('GET', '/api/v1/users/me', 401, actor=actor) + challenge = r['headers'].get('WWW-Authenticate', '') + check(challenge.lower().startswith('bearer'), + f'ожидался WWW-Authenticate: Bearer, получено {challenge!r}') + + # и сразу проверяем, что до истечения он работал — уже сделано выше + print('PASS: сессия истекла после TTL и вернула 401 Bearer') + + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/student-tests/test_resilience.py b/student-tests/test_resilience.py new file mode 100644 index 00000000..5f1b0f54 --- /dev/null +++ b/student-tests/test_resilience.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +import argparse +import subprocess +import time +import uuid +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, check, run # noqa: E402 + +REPO_ROOT = ROOT + + +def compose(*args, timeout=90): + return subprocess.run( + ['docker', 'compose', '--env-file', '.env', *args], + cwd=REPO_ROOT, capture_output=True, text=True, timeout=timeout, + ) + + +def make_user(c): + username = 'rs_' + uuid.uuid4().hex[:10] + password = 'T3st-' + uuid.uuid4().hex + c.call('POST', '/api/v1/users', 201, body={ + 'username': username, 'display_name': 'Res', 'password': password}) + import base64 + cred = base64.b64encode(f'{username}:{password}'.encode()).decode() + s = c.call('POST', '/api/v1/auth/sessions', 201, + headers={'Authorization': 'Basic ' + cred}, schema='Session')['json'] + return {'id': s['user']['id'], 'token': s['token']} + + +def wait_ready(c, seconds=90): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + try: + c.call('GET', '/health/ready', schema='Health') + return + except Exception: + time.sleep(1) + raise RuntimeError('health/ready не восстановился за %d секунд' % seconds) + + +def main(): + p = argparse.ArgumentParser() + p.add_argument('--service', choices=['redis', 'postgres'], required=True) + p.add_argument('--base-url', default=None) + args = p.parse_args() + + c = Client(args.base_url) + alice = make_user(c) + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') + + print(f'[{args.service}] останавливаем сервис') + r = compose('stop', args.service) + check(r.returncode == 0, f'docker compose stop: {r.stderr.strip()}') + + try: + time.sleep(2) + + # Защищённый endpoint должен вернуть 503 unavailable. + resp = c.call('GET', '/api/v1/users/me', 503, actor=alice) + code = resp['json']['error']['code'] + check(code == 'unavailable', + f'ожидался код unavailable, получено {code!r}') + + # Сообщение не должно раскрывать детали про Redis/Postgres/сеть. + msg = resp['json']['error']['message'].lower() + for bad in ('redis', 'postgres', 'sql', 'connection', 'refused', 'dial'): + check(bad not in msg, f'сообщение раскрывает "{bad}": {msg}') + + # Здоровье тоже должно репортить 503. + c.call('GET', '/health/ready', 503) + finally: + print(f'[{args.service}] запускаем сервис обратно') + r = compose('start', args.service) + check(r.returncode == 0, f'docker compose start: {r.stderr.strip()}') + wait_ready(c) + + # Токен alice всё ещё валиден после возврата сервиса. + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') + print(f'PASS: {args.service} недоступен → 503 unavailable без утечек; восстановление OK') + + +if __name__ == '__main__': + run(main) \ No newline at end of file -- 2.54.0 From fb9aef6a133f13f9ce962211b770f52b9e15e6b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 17:00:12 +0300 Subject: [PATCH 47/61] feat(track2): scaffold uneven seeding script with user bootstrap --- student-tests/seed_large.py | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 student-tests/seed_large.py diff --git a/student-tests/seed_large.py b/student-tests/seed_large.py new file mode 100644 index 00000000..100bbaa7 --- /dev/null +++ b/student-tests/seed_large.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Сидирует 100k сообщений в 24 чата с неравномерными размерами (трек 2).""" +import base64 +import sys +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) + +from client import Client, arguments, run # noqa: E402 + + +def make_user(c, label): + username = f'{label}_{uuid.uuid4().hex[:12]}' + password = 'T3st-' + uuid.uuid4().hex + user = c.call('POST', '/api/v1/users', 201, body={ + 'username': username, 'display_name': label.capitalize(), + 'password': password}, schema='User')['json'] + cred = base64.b64encode(f'{username}:{password}'.encode()).decode() + s = c.call('POST', '/api/v1/auth/sessions', 201, + headers={'Authorization': 'Basic ' + cred}, schema='Session')['json'] + return {'id': user['id'], 'username': username, 'token': s['token']} + + +def main(): + args = arguments('Сидирует неравномерные чаты для трека 2') + c = Client(args.base_url, args.ca_file) + alice = make_user(c, 'track2_a') + bob = make_user(c, 'track2_b') + print(f'alice={alice["id"]} bob={bob["id"]}') + + +if __name__ == '__main__': + run(main) \ No newline at end of file -- 2.54.0 From 4cb4bcc76abe70651c2cae7a557d4b6a92b3f8df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 17:11:26 +0300 Subject: [PATCH 48/61] feat(track2): add sequential per-chat message seeder --- student-tests/seed_large.py | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/student-tests/seed_large.py b/student-tests/seed_large.py index 100bbaa7..bf2815ed 100644 --- a/student-tests/seed_large.py +++ b/student-tests/seed_large.py @@ -2,6 +2,7 @@ """Сидирует 100k сообщений в 24 чата с неравномерными размерами (трек 2).""" import base64 import sys +import time import uuid from pathlib import Path @@ -23,12 +24,29 @@ def make_user(c, label): return {'id': user['id'], 'username': username, 'token': s['token']} +def seed_chat(base_url, ca_file, alice, bob, title, count): + c = Client(base_url, ca_file) + chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={ + 'title': title, 'member_ids': [alice['id'], bob['id']]}, + schema='Chat')['json'] + chat_id = chat['id'] + + started = time.monotonic() + for i in range(count): + c.call('POST', f'/api/v1/chats/{chat_id}/messages', 201, + actor=alice, body={'text': f'{title} #{i}'}, schema='Message') + elapsed = time.monotonic() - started + print(f' {title}: {count} сообщений за {elapsed:.1f}s') + return chat_id + + def main(): args = arguments('Сидирует неравномерные чаты для трека 2') c = Client(args.base_url, args.ca_file) alice = make_user(c, 'track2_a') bob = make_user(c, 'track2_b') - print(f'alice={alice["id"]} bob={bob["id"]}') + + seed_chat(args.base_url, args.ca_file, alice, bob, 'hot', 1000) if __name__ == '__main__': -- 2.54.0 From 900fb8f694cbbd7632c1b9c267bf0cbbbab8c21b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 17:48:35 +0300 Subject: [PATCH 49/61] feat(track2): assert dataset size and print representative chat ids --- student-tests/seed_large.py | 43 +++++++++++++++++++++++++++++++------ 1 file changed, 36 insertions(+), 7 deletions(-) diff --git a/student-tests/seed_large.py b/student-tests/seed_large.py index bf2815ed..4aeabad5 100644 --- a/student-tests/seed_large.py +++ b/student-tests/seed_large.py @@ -4,12 +4,13 @@ import base64 import sys import time import uuid +from concurrent.futures import ThreadPoolExecutor from pathlib import Path ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tests')) -from client import Client, arguments, run # noqa: E402 +from client import Client, arguments, check, run # noqa: E402 def make_user(c, label): @@ -24,19 +25,29 @@ def make_user(c, label): return {'id': user['id'], 'username': username, 'token': s['token']} -def seed_chat(base_url, ca_file, alice, bob, title, count): +def seed_chat(base_url, ca_file, alice, bob, title, count, workers=8): c = Client(base_url, ca_file) chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={ 'title': title, 'member_ids': [alice['id'], bob['id']]}, schema='Chat')['json'] chat_id = chat['id'] + per_worker = count // workers + remainder = count - per_worker * workers + + def worker(wid): + local = Client(base_url, ca_file, timeout=20) + n = per_worker + (1 if wid < remainder else 0) + for i in range(n): + local.call('POST', f'/api/v1/chats/{chat_id}/messages', 201, + actor=alice, body={'text': f'{title} #{wid}-{i}'}, + schema='Message') + started = time.monotonic() - for i in range(count): - c.call('POST', f'/api/v1/chats/{chat_id}/messages', 201, - actor=alice, body={'text': f'{title} #{i}'}, schema='Message') + with ThreadPoolExecutor(max_workers=workers) as pool: + list(pool.map(worker, range(workers))) elapsed = time.monotonic() - started - print(f' {title}: {count} сообщений за {elapsed:.1f}s') + print(f' {title}: {count} сообщений за {elapsed:.1f}s ({count/max(elapsed,0.001):.0f}/s)') return chat_id @@ -46,7 +57,25 @@ def main(): alice = make_user(c, 'track2_a') bob = make_user(c, 'track2_b') - seed_chat(args.base_url, args.ca_file, alice, bob, 'hot', 1000) + plan = ( + [('hot', 55_000)] + + [('medium-%d' % i, 10_000) for i in range(1, 4)] + + [('small-%d' % i, 1_000) for i in range(1, 11)] + + [('tiny-%d' % i, 500) for i in range(1, 11)] + ) + total = sum(n for _, n in plan) + check(total == 100_000, f'сумма {total} != 100000') + + result = {} + started = time.monotonic() + for title, count in plan: + result[title] = seed_chat(args.base_url, args.ca_file, alice, bob, title, count) + elapsed = time.monotonic() - started + + print(f'\nВсего {total} сообщений за {elapsed:.1f}s ({total/elapsed:.0f}/s)') + print('chat_id для EXPLAIN (сохраните эти значения):') + for title in ('hot', 'medium-1', 'small-1', 'tiny-1'): + print(f' {title}: {result[title]}') if __name__ == '__main__': -- 2.54.0 From 133c915d2d411edcc95b102c8373bd3a2c79fca9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 17:52:14 +0300 Subject: [PATCH 50/61] chore(gitignore): ignore local database dumps under evidence --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index b5a71896..fea269ea 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,7 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. + +# Локальные дампы БД (крупные, не для Git) +evidence/*.dump +evidence/*.sql.gz -- 2.54.0 From 72fe1d7fb9187a239fe43637917a5d17608aa8d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 18:19:47 +0300 Subject: [PATCH 51/61] feat(track2): compare baseline, covering and missing indexes on history query --- student-tests/compare_indexes.sh | 66 ++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 student-tests/compare_indexes.sh diff --git a/student-tests/compare_indexes.sh b/student-tests/compare_indexes.sh new file mode 100644 index 00000000..b0c521d8 --- /dev/null +++ b/student-tests/compare_indexes.sh @@ -0,0 +1,66 @@ +#!/bin/sh +set -eu + +chat_id="${1:-}" +if [ -z "$chat_id" ]; then + echo "usage: $0 " >&2 + echo "chat_id печатает student-tests/seed_large.py" >&2 + exit 2 +fi + +cd "$(dirname "$0")/.." +mkdir -p evidence + +COMPOSE="docker compose" +if ! $COMPOSE version >/dev/null 2>&1; then + COMPOSE="docker-compose" +fi + +psql() { + $COMPOSE --env-file .env exec -T postgres \ + psql -U messenger -d messenger -v ON_ERROR_STOP=1 "$@" +} + +QUERY="EXPLAIN (ANALYZE, BUFFERS) SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '$chat_id'::uuid ORDER BY created_at, id LIMIT 50;" + +reset_indexes() { + psql -c "DROP INDEX IF EXISTS messages_covering_small; + DROP INDEX IF EXISTS messages_covering_full; + DROP INDEX IF EXISTS messages_chat_created_id_idx;" >/dev/null +} + +{ + echo "# Сравнение индексов: keyset-пагинация, chat_id=$chat_id" + echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)" + echo + + echo "## A. Baseline (chat_id, created_at, id)" + reset_indexes + psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null + psql -c "$QUERY" + echo + + echo "## B1. Covering (chat_id, created_at, id) INCLUDE (sender_id)" + reset_indexes + psql -c "CREATE INDEX messages_covering_small ON messages (chat_id, created_at, id) INCLUDE (sender_id); ANALYZE messages;" >/dev/null + psql -c "$QUERY" + echo + + echo "## B2. Covering (chat_id, created_at, id) INCLUDE (sender_id, text)" + reset_indexes + psql -c "CREATE INDEX messages_covering_full ON messages (chat_id, created_at, id) INCLUDE (sender_id, text); ANALYZE messages;" >/dev/null + psql -c "$QUERY" + echo + + echo "## C. Без индекса (Seq Scan)" + reset_indexes + psql -c "ANALYZE messages;" >/dev/null + psql -c "$QUERY" + echo + + echo "## Восстанавливаем baseline" + reset_indexes + psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null + psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexrelid)) AS size + FROM pg_stat_user_indexes WHERE relname='messages' ORDER BY indexname;" +} | tee evidence/index_comparison.txt -- 2.54.0 From ebe402c3c84022f87d1cf0c3bf5ccefd67be302c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 18:38:23 +0300 Subject: [PATCH 52/61] feat(track2): benchmark write cost for baseline and covering indexes --- student-tests/write_bench.sh | 74 ++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 student-tests/write_bench.sh diff --git a/student-tests/write_bench.sh b/student-tests/write_bench.sh new file mode 100644 index 00000000..8551d28e --- /dev/null +++ b/student-tests/write_bench.sh @@ -0,0 +1,74 @@ +#!/bin/sh +set -eu + +cd "$(dirname "$0")/.." +mkdir -p evidence + +COMPOSE="docker compose" +if ! $COMPOSE version >/dev/null 2>&1; then + COMPOSE="docker-compose" +fi + +psql() { + $COMPOSE --env-file .env exec -T postgres \ + psql -U messenger -d messenger -v ON_ERROR_STOP=1 "$@" +} + +N=5000 + +CHAT_ID=$(psql -t -A -c "SELECT id FROM chats WHERE title='hot' LIMIT 1") +USER_ID=$(psql -t -A -c "SELECT id FROM users LIMIT 1") +if [ -z "$CHAT_ID" ] || [ -z "$USER_ID" ]; then + echo "Нет тестового чата 'hot' или пользователя. Сначала запустите seed_large.py" >&2 + exit 2 +fi + +reset_indexes() { + psql -c "DROP INDEX IF EXISTS messages_covering_small; + DROP INDEX IF EXISTS messages_chat_created_id_idx;" >/dev/null +} + +bench() { + label="$1" + echo "## $label" + psql </dev/null + bench "INSERT $N rows" + psql -c "DELETE FROM messages WHERE text LIKE 'bench %';" >/dev/null + echo + + echo "## B. Covering (chat_id, created_at, id) INCLUDE (sender_id)" + reset_indexes + psql -c "CREATE INDEX messages_covering_small ON messages (chat_id, created_at, id) INCLUDE (sender_id);" >/dev/null + bench "INSERT $N rows" + psql -c "DELETE FROM messages WHERE text LIKE 'bench %';" >/dev/null + echo + + echo "## Восстанавливаем baseline" + reset_indexes + psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null +} | tee evidence/write_cost.txt -- 2.54.0 From fea89500c11e33a4b0000de6414b1a31263b34dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 19:02:14 +0300 Subject: [PATCH 53/61] feat(track2): add pg_dump snapshot script for the messenger database --- student-tests/backup_restore.sh | 37 +++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 student-tests/backup_restore.sh diff --git a/student-tests/backup_restore.sh b/student-tests/backup_restore.sh new file mode 100644 index 00000000..aa18fcb8 --- /dev/null +++ b/student-tests/backup_restore.sh @@ -0,0 +1,37 @@ +#!/bin/sh +set -eu + +cd "$(dirname "$0")/.." +mkdir -p evidence + +COMPOSE="docker compose" +if ! $COMPOSE version >/dev/null 2>&1; then + COMPOSE="docker-compose" +fi + +DUMP_FILE="$(pwd)/evidence/dump_$(date +%Y%m%d_%H%M%S).dump" + +{ + echo "# Backup → Restore → сверка" + echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)" + echo + + echo "## Снимок источника" + SRC_COUNTS=$($COMPOSE --env-file .env exec -T postgres \ + psql -U messenger -d messenger -t -A -c " + SELECT 'users=' || count(*) FROM users + UNION ALL SELECT 'chats=' || count(*) FROM chats + UNION ALL SELECT 'messages=' || count(*) FROM messages + UNION ALL SELECT 'sessions=' || count(*) FROM sessions;") + echo "$SRC_COUNTS" + echo + + echo "## pg_dump -Fc" + START=$(date +%s) + $COMPOSE --env-file .env exec -T postgres \ + pg_dump -U messenger -Fc -d messenger > "$DUMP_FILE" + END=$(date +%s) + echo "файл: $DUMP_FILE" + echo "размер: $(du -h "$DUMP_FILE" | cut -f1)" + echo "время дампа: $((END - START))s" +} | tee evidence/backup_restore.txt -- 2.54.0 From 004df0ec973b393016c3f1ab03bb6a6aa924dc61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 19:14:38 +0300 Subject: [PATCH 54/61] feat(track2): restore dump into an isolated postgres container --- student-tests/backup_restore.sh | 34 +++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/student-tests/backup_restore.sh b/student-tests/backup_restore.sh index aa18fcb8..91bc7740 100644 --- a/student-tests/backup_restore.sh +++ b/student-tests/backup_restore.sh @@ -9,8 +9,13 @@ if ! $COMPOSE version >/dev/null 2>&1; then COMPOSE="docker-compose" fi +RESTORE_CONTAINER=pg_restore_target +RESTORE_PORT=5433 +RESTORE_VOLUME=mtusi_restore_test DUMP_FILE="$(pwd)/evidence/dump_$(date +%Y%m%d_%H%M%S).dump" +docker rm -f "$RESTORE_CONTAINER" >/dev/null 2>&1 || true + { echo "# Backup → Restore → сверка" echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)" @@ -34,4 +39,33 @@ DUMP_FILE="$(pwd)/evidence/dump_$(date +%Y%m%d_%H%M%S).dump" echo "файл: $DUMP_FILE" echo "размер: $(du -h "$DUMP_FILE" | cut -f1)" echo "время дампа: $((END - START))s" + echo + + echo "## Поднимаем целевой контейнер $RESTORE_CONTAINER на :$RESTORE_PORT" + docker volume create "$RESTORE_VOLUME" >/dev/null + docker run -d --name "$RESTORE_CONTAINER" \ + -e POSTGRES_PASSWORD=restore-only \ + -e POSTGRES_USER=messenger \ + -e POSTGRES_DB=messenger \ + -p "$RESTORE_PORT:5432" \ + -v "$RESTORE_VOLUME:/var/lib/postgresql/data" \ + postgres:16.4-alpine >/dev/null + + echo "Ждём готовности..." + i=0 + until docker exec "$RESTORE_CONTAINER" pg_isready -U messenger -d messenger >/dev/null 2>&1; do + i=$((i + 1)) + if [ "$i" -gt 30 ]; then + echo "контейнер не поднялся за 30 секунд" >&2 + exit 1 + fi + sleep 1 + done + + echo "## pg_restore" + START=$(date +%s) + docker exec -i "$RESTORE_CONTAINER" \ + pg_restore -U messenger -d messenger --no-owner --no-acl < "$DUMP_FILE" + END=$(date +%s) + echo "время восстановления: $((END - START))s" } | tee evidence/backup_restore.txt -- 2.54.0 From b310835e03141b2e2022b96449fdc248cb736948 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 19:25:51 +0300 Subject: [PATCH 55/61] feat(track2): verify counters and checksums after restore --- student-tests/backup_restore.sh | 44 +++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/student-tests/backup_restore.sh b/student-tests/backup_restore.sh index 91bc7740..c99505cd 100644 --- a/student-tests/backup_restore.sh +++ b/student-tests/backup_restore.sh @@ -29,6 +29,13 @@ docker rm -f "$RESTORE_CONTAINER" >/dev/null 2>&1 || true UNION ALL SELECT 'messages=' || count(*) FROM messages UNION ALL SELECT 'sessions=' || count(*) FROM sessions;") echo "$SRC_COUNTS" + + SRC_SAMPLE=$($COMPOSE --env-file .env exec -T postgres \ + psql -U messenger -d messenger -t -A -c " + SELECT md5(string_agg(id::text || '|' || text || '|' || created_at::text, + E'\n' ORDER BY id)) + FROM (SELECT id, text, created_at FROM messages ORDER BY id LIMIT 1000) s;") + echo "md5 первых 1000 сообщений: $SRC_SAMPLE" echo echo "## pg_dump -Fc" @@ -68,4 +75,41 @@ docker rm -f "$RESTORE_CONTAINER" >/dev/null 2>&1 || true pg_restore -U messenger -d messenger --no-owner --no-acl < "$DUMP_FILE" END=$(date +%s) echo "время восстановления: $((END - START))s" + echo + + echo "## Снимок цели" + DST_COUNTS=$(docker exec "$RESTORE_CONTAINER" \ + psql -U messenger -d messenger -t -A -c " + SELECT 'users=' || count(*) FROM users + UNION ALL SELECT 'chats=' || count(*) FROM chats + UNION ALL SELECT 'messages=' || count(*) FROM messages + UNION ALL SELECT 'sessions=' || count(*) FROM sessions;") + echo "$DST_COUNTS" + + DST_SAMPLE=$(docker exec "$RESTORE_CONTAINER" \ + psql -U messenger -d messenger -t -A -c " + SELECT md5(string_agg(id::text || '|' || text || '|' || created_at::text, + E'\n' ORDER BY id)) + FROM (SELECT id, text, created_at FROM messages ORDER BY id LIMIT 1000) s;") + echo "md5 первых 1000 сообщений: $DST_SAMPLE" + echo + + echo "## Сверка" + [ "$SRC_COUNTS" = "$DST_COUNTS" ] && echo "PASS: счётчики совпадают" \ + || echo "FAIL: счётчики различаются" + [ "$SRC_SAMPLE" = "$DST_SAMPLE" ] && echo "PASS: контрольные суммы совпадают" \ + || echo "FAIL: контрольные суммы различаются" + echo + + echo "## Индексы в восстановленной БД" + docker exec "$RESTORE_CONTAINER" \ + psql -U messenger -d messenger -c " + SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) AS size + FROM pg_indexes WHERE tablename='messages' ORDER BY indexname;" } | tee evidence/backup_restore.txt + +echo +echo "Восстановленный контейнер оставлен для ручной проверки:" +echo " docker exec -it $RESTORE_CONTAINER psql -U messenger -d messenger" +echo "Удалить после проверки:" +echo " docker rm -f $RESTORE_CONTAINER && docker volume rm $RESTORE_VOLUME" -- 2.54.0 From 61207bb514832022d7c08cb540767aafe340fb06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 19:36:22 +0300 Subject: [PATCH 56/61] docs(student-tests): lab2 document track two commands and evidence files --- student-tests/README.md | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/student-tests/README.md b/student-tests/README.md index 7524c0d8..954d3958 100644 --- a/student-tests/README.md +++ b/student-tests/README.md @@ -34,4 +34,25 @@ endpoint отдают 503 unavailable (не 401 и не 500), и запуска student-tests/explain_history.sh `seed_messages.py` печатает `chat_id`; передай его в `explain_history.sh`, -результат сохранится в `evidence/explain_history.txt`. \ No newline at end of file +результат сохранится в `evidence/explain_history.txt`. +## Трек 2: план запроса и восстановление + +Исследование на ≥100 000 сообщениях с неравномерными размерами чатов. + + python student-tests/seed_large.py + # сохранить chat_id из вывода в evidence/chat_ids.txt + + student-tests/explain_history.sh + student-tests/compare_indexes.sh + student-tests/write_bench.sh + student-tests/backup_restore.sh + +Результаты попадают в `evidence/`: + +- `explain_history.txt` — EXPLAIN (ANALYZE, BUFFERS) ключевого запроса +- `index_comparison.txt` — baseline vs covering vs Seq Scan +- `write_cost.txt` — время 5000 INSERT под разными индексами +- `backup_restore.txt` — pg_dump → pg_restore → сверка счётчиков и md5 + +Восстановленный контейнер `pg_restore_target` оставлен для ручной проверки +и удаляется вручную после эксперимента. -- 2.54.0 From 55f990675824653a67908f177bc8612c61159907 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 19:42:15 +0300 Subject: [PATCH 57/61] fix(track2): query pg_indexes for index sizes in compare and write bench --- student-tests/compare_indexes.sh | 6 +++--- student-tests/write_bench.sh | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/student-tests/compare_indexes.sh b/student-tests/compare_indexes.sh index b0c521d8..d211e25f 100644 --- a/student-tests/compare_indexes.sh +++ b/student-tests/compare_indexes.sh @@ -61,6 +61,6 @@ reset_indexes() { echo "## Восстанавливаем baseline" reset_indexes psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null - psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexrelid)) AS size - FROM pg_stat_user_indexes WHERE relname='messages' ORDER BY indexname;" -} | tee evidence/index_comparison.txt + psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) AS size + FROM pg_indexes WHERE tablename='messages' ORDER BY indexname;" +} | tee evidence/index_comparison.txt \ No newline at end of file diff --git a/student-tests/write_bench.sh b/student-tests/write_bench.sh index 8551d28e..ac49bbb1 100644 --- a/student-tests/write_bench.sh +++ b/student-tests/write_bench.sh @@ -43,8 +43,8 @@ BEGIN END LOOP; END \$\$; SQL - psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexrelid)) AS size - FROM pg_stat_user_indexes WHERE relname='messages' ORDER BY indexname;" + psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) AS size + FROM pg_indexes WHERE tablename='messages' ORDER BY indexname;" echo } @@ -71,4 +71,4 @@ SQL echo "## Восстанавливаем baseline" reset_indexes psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null -} | tee evidence/write_cost.txt +} | tee evidence/write_cost.txt \ No newline at end of file -- 2.54.0 From 7c0386f710e4ae5fbd0068d362923e733ef0998c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 19:50:44 +0300 Subject: [PATCH 58/61] docs(evidence): add track two dataset, explain plans and chat identifiers --- evidence/chat_ids.txt | 4 ++++ evidence/explain_history.txt | 26 ++++++++++++------------- evidence/explain_history_10k.txt | 33 ++++++++++++++++++++++++++++++++ evidence/seed_large.txt | 31 ++++++++++++++++++++++++++++++ 4 files changed, 81 insertions(+), 13 deletions(-) create mode 100644 evidence/chat_ids.txt create mode 100644 evidence/explain_history_10k.txt create mode 100644 evidence/seed_large.txt diff --git a/evidence/chat_ids.txt b/evidence/chat_ids.txt new file mode 100644 index 00000000..075a1073 --- /dev/null +++ b/evidence/chat_ids.txt @@ -0,0 +1,4 @@ +hot=349f1aef-3bbc-42d1-8724-e8d22b8c2253 +medium-1=532a232a-4038-4d2a-96dd-e5c901e868a2 +small-1=950e3367-500a-43b3-b824-b5cf521839b9 +tiny-1=c099542c-e3c2-49ff-ab10-5389ed2450af diff --git a/evidence/explain_history.txt b/evidence/explain_history.txt index 8f2a0c0a..65caa044 100644 --- a/evidence/explain_history.txt +++ b/evidence/explain_history.txt @@ -1,19 +1,19 @@ # EXPLAIN (ANALYZE, BUFFERS) для истории сообщений -# date: 2026-10-02T11:01:11Z -# chat_id: cf9e8ca9-d08c-41d1-b55f-18c9fba43aec +# date: 2026-10-02T11:28:14Z +# chat_id: 349f1aef-3bbc-42d1-8724-e8d22b8c2253 ## Ключевой запрос пагинации - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------ - Limit (cost=0.29..4.38 rows=50 width=73) (actual time=0.021..0.029 rows=50 loops=1) - Buffers: shared hit=3 - -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..819.43 rows=10000 width=73) (actual time=0.020..0.025 rows=50 loops=1) - Index Cond: (chat_id = 'cf9e8ca9-d08c-41d1-b55f-18c9fba43aec'::uuid) - Buffers: shared hit=3 + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.42..8.05 rows=50 width=69) (actual time=0.025..0.042 rows=50 loops=1) + Buffers: shared hit=45 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..8419.02 rows=55133 width=69) (actual time=0.024..0.038 rows=50 loops=1) + Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid) + Buffers: shared hit=45 Planning: - Buffers: shared hit=111 - Planning Time: 0.694 ms - Execution Time: 0.063 ms + Buffers: shared hit=109 + Planning Time: 0.611 ms + Execution Time: 0.064 ms (9 rows) @@ -28,6 +28,6 @@ ## Оценка размера и количества estimated_rows | total_size ----------------+------------ - 10222 | 2264 kB + 110222 | 25 MB (1 row) diff --git a/evidence/explain_history_10k.txt b/evidence/explain_history_10k.txt new file mode 100644 index 00000000..8f2a0c0a --- /dev/null +++ b/evidence/explain_history_10k.txt @@ -0,0 +1,33 @@ +# EXPLAIN (ANALYZE, BUFFERS) для истории сообщений +# date: 2026-10-02T11:01:11Z +# chat_id: cf9e8ca9-d08c-41d1-b55f-18c9fba43aec + +## Ключевой запрос пагинации + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..4.38 rows=50 width=73) (actual time=0.021..0.029 rows=50 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..819.43 rows=10000 width=73) (actual time=0.020..0.025 rows=50 loops=1) + Index Cond: (chat_id = 'cf9e8ca9-d08c-41d1-b55f-18c9fba43aec'::uuid) + Buffers: shared hit=3 + Planning: + Buffers: shared hit=111 + Planning Time: 0.694 ms + Execution Time: 0.063 ms +(9 rows) + + +## Индексы таблицы messages + indexname | indexdef +------------------------------+---------------------------------------------------------------------------------------------------- + messages_pkey | CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id) + messages_chat_created_id_idx | CREATE INDEX messages_chat_created_id_idx ON public.messages USING btree (chat_id, created_at, id) +(2 rows) + + +## Оценка размера и количества + estimated_rows | total_size +----------------+------------ + 10222 | 2264 kB +(1 row) + diff --git a/evidence/seed_large.txt b/evidence/seed_large.txt new file mode 100644 index 00000000..009ee8ac --- /dev/null +++ b/evidence/seed_large.txt @@ -0,0 +1,31 @@ +hot: 55000 сообщений за 61.7s (891/s) +medium-1: 10000 сообщений за 11.4s (879/s) +medium-2: 10000 сообщений за 11.4s (879/s) +medium-3: 10000 сообщений за 11.7s (854/s) +small-1: 1000 сообщений за 1.3s (781/s) +small-2: 1000 сообщений за 1.2s (800/s) +small-3: 1000 сообщений за 1.2s (820/s) +small-4: 1000 сообщений за 1.3s (790/s) +small-5: 1000 сообщений за 1.2s (810/s) +small-6: 1000 сообщений за 1.2s (820/s) +small-7: 1000 сообщений за 1.3s (791/s) +small-8: 1000 сообщений за 1.2s (810/s) +small-9: 1000 сообщений за 1.2s (820/s) +small-10: 1000 сообщений за 1.2s (810/s) +tiny-1: 500 сообщений за 0.7s (761/s) +tiny-2: 500 сообщений за 0.7s (761/s) +tiny-3: 500 сообщений за 0.7s (762/s) +tiny-4: 500 сообщений за 0.6s (780/s) +tiny-5: 500 сообщений за 0.6s (800/s) +tiny-6: 500 сообщений за 0.7s (762/s) +tiny-7: 500 сообщений за 0.6s (781/s) +tiny-8: 500 сообщений за 0.7s (744/s) +tiny-9: 500 сообщений за 0.7s (728/s) +tiny-10: 500 сообщений за 0.7s (762/s) + +Всего 100000 сообщений за 115.5s (866/s) +chat_id для EXPLAIN: + hot: 349f1aef-3bbc-42d1-8724-e8d22b8c2253 + medium-1: 532a232a-4038-4d2a-96dd-e5c901e868a2 + small-1: 950e3367-500a-43b3-b824-b5cf521839b9 + tiny-1: c099542c-e3c2-49ff-ab10-5389ed2450af \ No newline at end of file -- 2.54.0 From d450c08f97a97c3629bf55510dda30b39297b885 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 20:05:33 +0300 Subject: [PATCH 59/61] docs(evidence): add index comparison, write cost and restore verification --- evidence/backup_restore.txt | 38 ++++++++++++++++ evidence/index_comparison.txt | 81 +++++++++++++++++++++++++++++++++++ evidence/write_cost.txt | 31 ++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 evidence/backup_restore.txt create mode 100644 evidence/index_comparison.txt create mode 100644 evidence/write_cost.txt diff --git a/evidence/backup_restore.txt b/evidence/backup_restore.txt new file mode 100644 index 00000000..d1f9072d --- /dev/null +++ b/evidence/backup_restore.txt @@ -0,0 +1,38 @@ +# Backup → Restore → сверка +# date: 2026-10-02T16:46:16Z + +## Снимок источника +users=52 +chats=37 +messages=110222 +sessions=0 +md5 первых 1000 сообщений: f3c9c53ed0fd56da19a01f213d0ff2f0 + +## pg_dump -Fc +файл: /mnt/c/Users/Антон/Desktop/4_курс/mtusi2026lab2-fork/evidence/dump_20261002_194616.dump +размер: 3.4M +время дампа: 1s + +## Поднимаем целевой контейнер pg_restore_target на :5433 +Ждём готовности... +## pg_restore +время восстановления: 0s + +## Снимок цели +users=52 +chats=37 +messages=110222 +sessions=0 +md5 первых 1000 сообщений: f3c9c53ed0fd56da19a01f213d0ff2f0 + +## Сверка +PASS: счётчики совпадают +PASS: контрольные суммы совпадают + +## Индексы в восстановленной БД + indexname | size +------------------------------+--------- + messages_chat_created_id_idx | 6360 kB + messages_pkey | 3424 kB +(2 rows) + diff --git a/evidence/index_comparison.txt b/evidence/index_comparison.txt new file mode 100644 index 00000000..36880ac9 --- /dev/null +++ b/evidence/index_comparison.txt @@ -0,0 +1,81 @@ +# Сравнение индексов: keyset-пагинация, chat_id=349f1aef-3bbc-42d1-8724-e8d22b8c2253 +# date: 2026-10-02T16:45:25Z + +## A. Baseline (chat_id, created_at, id) + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.42..7.31 rows=50 width=69) (actual time=0.029..0.046 rows=50 loops=1) + Buffers: shared hit=42 read=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..7619.95 rows=55273 width=69) (actual time=0.028..0.042 rows=50 loops=1) + Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid) + Buffers: shared hit=42 read=3 + Planning: + Buffers: shared hit=106 read=1 + Planning Time: 0.664 ms + Execution Time: 0.070 ms +(9 rows) + + +## B1. Covering (chat_id, created_at, id) INCLUDE (sender_id) + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..7.77 rows=50 width=69) (actual time=0.027..0.048 rows=50 loops=1) + Buffers: shared hit=42 read=4 + -> Index Scan using messages_covering_small on messages (cost=0.42..8096.41 rows=55056 width=69) (actual time=0.026..0.044 rows=50 loops=1) + Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid) + Buffers: shared hit=42 read=4 + Planning: + Buffers: shared hit=111 read=1 + Planning Time: 0.639 ms + Execution Time: 0.070 ms +(9 rows) + + +## B2. Covering (chat_id, created_at, id) INCLUDE (sender_id, text) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..4.40 rows=50 width=69) (actual time=0.038..0.044 rows=50 loops=1) + Buffers: shared hit=1 read=3 + -> Index Only Scan using messages_covering_full on messages (cost=0.42..4393.54 rows=55144 width=69) (actual time=0.037..0.041 rows=50 loops=1) + Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid) + Heap Fetches: 0 + Buffers: shared hit=1 read=3 + Planning: + Buffers: shared hit=112 read=1 + Planning Time: 0.717 ms + Execution Time: 0.071 ms +(10 rows) + + +## C. Без индекса (Seq Scan) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=4314.02..4319.77 rows=50 width=69) (actual time=7.709..9.590 rows=50 loops=1) + Buffers: shared hit=1486 + -> Gather Merge (cost=4314.02..7988.96 rows=31956 width=69) (actual time=7.707..9.585 rows=50 loops=1) + Workers Planned: 1 + Workers Launched: 1 + Buffers: shared hit=1486 + -> Sort (cost=3314.01..3393.90 rows=31956 width=69) (actual time=5.760..5.763 rows=50 loops=2) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 32kB + Buffers: shared hit=1486 + Worker 0: Sort Method: top-N heapsort Memory: 32kB + -> Parallel Seq Scan on messages (cost=0.00..2252.46 rows=31956 width=69) (actual time=0.009..3.673 rows=27500 loops=2) + Filter: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid) + Rows Removed by Filter: 27611 + Buffers: shared hit=1442 + Planning: + Buffers: shared hit=84 + Planning Time: 0.598 ms + Execution Time: 9.660 ms +(19 rows) + + +## Восстанавливаем baseline + indexname | size +------------------------------+--------- + messages_chat_created_id_idx | 6360 kB + messages_pkey | 4568 kB +(2 rows) + diff --git a/evidence/write_cost.txt b/evidence/write_cost.txt new file mode 100644 index 00000000..f30cca76 --- /dev/null +++ b/evidence/write_cost.txt @@ -0,0 +1,31 @@ +# Стоимость записи: 5000 INSERT в один чат +# date: 2026-10-02T16:45:29Z +# chat_id: 349f1aef-3bbc-42d1-8724-e8d22b8c2253 + +## A. Baseline (chat_id, created_at, id) +## INSERT 5000 rows +Timing is on. +DO +Time: 353.267 ms + indexname | size +------------------------------+--------- + messages_chat_created_id_idx | 6768 kB + messages_pkey | 4736 kB +(2 rows) + + + +## B. Covering (chat_id, created_at, id) INCLUDE (sender_id) +## INSERT 5000 rows +Timing is on. +DO +Time: 288.259 ms + indexname | size +-------------------------+--------- + messages_covering_small | 8848 kB + messages_pkey | 4944 kB +(2 rows) + + + +## Восстанавливаем baseline -- 2.54.0 From dbfb5c58f421bcd19d99f6770a8861506c65b946 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 20:48:00 +0300 Subject: [PATCH 60/61] docs(report): lab2 ai helps generate report --- REPORT.md | 354 +++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 337 insertions(+), 17 deletions(-) diff --git a/REPORT.md b/REPORT.md index e42f2b05..1682cd3c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,357 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Голиков Антон / БВТ2303 +- Целевая оценка: 5, трек 2 «План запроса и восстановление» +- Commit/PR: ветка `solution/BVT2303-Golikov`, PR будет открыт после публикации +- Использованные источники и помощь ИИ: + - Документация: PostgreSQL 16 (EXPLAIN, pg_dump, pg_indexes), pgx/v5, gin, + go-redis v9, goose, Argon2id (RFC 9106). + - Материалы курса: `contracts/openapi.json`, `contracts/README.md`, `tests/README.md`. + - ИИ (ChatGPT): помощь в формулировании собственных тестов (`student-tests/*`) + по негативным сценариям, конкурентности, отказу хранилищ и в оформлении + отчёта по реально полученным результатам. Архитектурные решения, код + сервера и финальные тексты проверены и адаптированы вручную. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Требования.** Docker Desktop, Python 3.9+, +make, `docker compose` в `PATH`. Проверено на Windows 10 + Docker Desktop. +Persistence-сценарий запускается из WSL 2, потому что `tests/resilience.py` +вызывает `.sh`-хук напрямую через `subprocess` без shell. + +**Версии образов (закреплены в `compose.yaml`).** + +- `postgres:16.4-alpine` +- `redis:7.4-alpine` +- API собирается из `Dockerfile` этого репозитория. + +**Создание локальных секретов.** Каталог `secrets/` в `.gitignore`; в +репозиторий не попадает. + +```sh +mkdir -p secrets +printf '%s' "$(openssl rand -base64 24)" > secrets/postgres_password +printf '%s' 'postgres://messenger:ПАРОЛЬ@postgres:5432/messenger?sslmode=disable' \ + > secrets/database_url +printf '%s' 'redis://redis:6379/0' > secrets/cache_url +chmod 600 secrets/* +``` + +`.env` создаётся из `.env.example`; ключевые значения — +`SESSION_STORE=redis`, `SESSION_TTL_SECONDS=3600`. + +**Build и запуск.** + +```sh +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +until curl -fs http://localhost:8080/health/ready >/dev/null; do sleep 1; done +``` + +Миграции применяются автоматически при старте API (`goose.UpContext` на +`//go:embed migrations/*.sql`); отдельная команда не требуется. + +**Проверки.** + +```sh +make check +python tests/smoke.py --base-url http://localhost:8080 +python student-tests/run_all.py --base-url http://localhost:8080 +``` + +**Persistence (WSL).** + +```sh +python3 tests/resilience.py --mode persistence \ + --action-script scripts/restart.sh \ + --base-url http://localhost:8080 +``` + +**Отказы хранилищ (Windows допустим).** + +```sh +python student-tests/test_resilience.py --service postgres --base-url http://localhost:8080 +python student-tests/test_resilience.py --service redis --base-url http://localhost:8080 +``` + +**Остановка и удаление данных.** + +```sh +# Остановка без потери данных: +docker compose --env-file .env stop + +# Полное удаление учебных данных: +docker compose --env-file .env down -v +docker volume rm mtusi_restore_test +rm -f secrets/* +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент ──HTTP──▶ api (Go, gin) ──pgx──▶ postgres:16.4 ── volume postgres_data + │ + └──go-redis──▶ redis:7.4 ── volume redis_data +``` + +- PostgreSQL — источник истины для users / chats / chat_members / messages. +- Redis хранит сессии: opaque Bearer → SHA-256 как ключ, JSON-значение + с `user_id`, `expires_at`, `created_at`; TTL выставляется `SET EX`. +- Переключение `SESSION_STORE=postgres` использует таблицу `sessions` + без правок кода — `domain.SessionRepository` реализован дважды. + +**Транзакционные границы.** + +- Создание чата — одна транзакция: `INSERT chats` + `INSERT chat_members` + для всех участников, `defer tx.Rollback` при нарушении FK/UNIQUE. +- Регистрация — один INSERT с UNIQUE-индексом на `username`; гонка + разрешается на уровне БД (`23505` → `409 conflict`). +- Отправка сообщения — один INSERT, предварительная проверка членства. + +**Изменения lab1→lab2 по `COURSE.md`:** + +1. `POST /users` требует `password` (12–128 code points). +2. `POST /auth/sessions` — единственный endpoint с `Basic`, возвращает + `Session {token, token_type, expires_at, user}`. +3. Все защищённые endpoint требуют `Authorization: Bearer `. + `X-User-Id` игнорируется. + +**Решения уровня 4.** + +- Пароли: Argon2id (m=64 MiB, t=3, p=4, salt 16 B, key 32 B), PHC-формат, + `subtle.ConstantTimeCompare`. +- Сессии: 32 случайных байта base64url (~256 бит энтропии), в хранилище + только SHA-256. +- Пагинация: keyset `(created_at, id)` ASC, курсор — base64url от + `scope|RFC3339Nano|uuid`. Scope привязан к ресурсу; чужой курсор → 400. +- Пул БД: `pgxpool.MaxConns=10`, `HealthCheckPeriod=10s`, `ConnectTimeout=5s`. +- Redis: `DialTimeout/ReadTimeout/WriteTimeout=700ms`, `MaxRetries=1`. + `BearerAuth` оборачивает `Resolve` в `context.WithTimeout(3s)`. + +**Переменные `.env.example` в реальной конфигурации.** + +| Переменная | Значение | Роль | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT` | `0.0.0.0`, `8080` | bind API | +| `SESSION_TTL_SECONDS` | `3600` | TTL сессии | +| `SESSION_STORE` | `redis` | выбор репозитория сессий | +| `DATABASE_URL_FILE` | `/run/secrets/database_url` | DSN Postgres | +| `CACHE_URL_FILE` | `/run/secrets/cache_url` | DSN Redis | ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий README | Команда | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `python tests/smoke.py` | `PASS: lab2 public API scenario` | — | +| Persistence | `python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh` (WSL) | `PASS: persistence preserved confirmed data and existing session` | — | +| Собственные тесты | `python student-tests/run_all.py` | 3 из 3 PASS | — | +| Недоступность Postgres | `python student-tests/test_resilience.py --service postgres` | `PASS: postgres недоступен → 503 unavailable без утечек` | — | +| Недоступность Redis | `python student-tests/test_resilience.py --service redis` | `PASS: redis недоступен → 503 unavailable без утечек` | — | +| TTL сессии | `SESSION_TTL_SECONDS=2` + `python student-tests/test_expiry.py` | 401 Bearer после TTL | — | +| Гонка за username | `test_concurrency.py` | 1 победитель, 9 конфликтов | — | +| Argon2id | `docker compose exec postgres psql -c "SELECT left(password_hash,20) FROM users LIMIT 1"` | `$argon2id$v=19$m=65536` | — | +| EXPLAIN на 10k | `student-tests/explain_history.sh ` | Index Scan, Buffers=3, Exec 0.063 ms | `evidence/explain_history_10k.txt` | +| EXPLAIN на 100k | `student-tests/explain_history.sh ` | Index Scan, Buffers=45, Exec 0.064 ms | `evidence/explain_history.txt` | +| Трек 5: 100k неравномерных | `python student-tests/seed_large.py` | 100 000 сообщений за 115.5 с (866/s) | `evidence/seed_large.txt` | +| Трек 5: сравнение индексов | `student-tests/compare_indexes.sh ` | A/B1/B2/C, Index Only Scan на B2 | `evidence/index_comparison.txt` | +| Трек 5: стоимость записи | `student-tests/write_bench.sh` | 5000 INSERT под A и B1 | `evidence/write_cost.txt` | +| Трек 5: backup/restore | `student-tests/backup_restore.sh` | PASS счётчиков и md5 | `evidence/backup_restore.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Стенд.** Windows 11 + Docker Desktop на WSL 2, 4 vCPU, 16 GB RAM. +PostgreSQL 16.4, Redis 7.4, приложение — Go 1.26, один контейнер API. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +**Сценарий 1: недоступность Postgres.** + +- Воздействие: `docker compose stop postgres`. +- Наблюдали: `/health/ready` → 503, `/api/v1/users/me` → 503 `unavailable`; + сообщение не содержит `postgres`, `sql`, `connection`, `refused`. + Существующий Bearer-токен действителен после возврата Postgres. +- Восстановление: 2–3 с. + +**Сценарий 2: недоступность Redis.** + +- Воздействие: `docker compose stop redis`. +- Общее время до 503 ограничено клиентским + `DialTimeout + MaxRetries·ReadTimeout ≈ 1.5 с`. +- Наблюдали: то же, что для Postgres. +- Восстановление: ~1 с. + +**Сценарий 3: полный перезапуск стека.** + +- Воздействие: `scripts/restart.sh` — `stop api postgres redis`, затем + `start` с ожиданием `healthy`, без `down -v`. +- Ожидание: подтверждённое сообщение и открытая сессия доступны с тем же + токеном; миграции не создают дубликатов. +- Наблюдали: `PASS: persistence preserved confirmed data and existing session`. + +**Сценарий 4: конкурентность.** + +- 100 сообщений из 10 потоков: ровно 100 сообщений без дублей. +- 10 параллельных регистраций одного username: 1 успех + 9 × `409`. + +## Трек 5. План запроса и восстановление + +### Гипотеза + +Ключевой запрос пагинации `SELECT ... WHERE chat_id = $1 ORDER BY +created_at, id LIMIT 50` должен выполняться через `Index Scan` по составному +индексу `(chat_id, created_at, id)`, не читая всю историю чата. Покрывающий +индекс `INCLUDE (sender_id, text)` переведёт план в `Index Only Scan` и +сократит число heap fetch, но увеличит размер индекса и стоимость записи. + +### Методика + +- Датасет: 100 000 сообщений, 24 чата, распределение 1×55k, 3×10k, 10×1k, 10×500. + Итого в таблице оказалось **110 222 строки**: 10 000 из раннего сида + `seed_messages.py` плюс остатки от smoke-прогонов. +- Запись через HTTP API, 8 параллельных клиентов, `pgxpool.MaxConns=10`. +- Полное время сида: 115.5 с, средняя пропускная способность 866 сообщений/с. +- 4 конфигурации: A (baseline), B1 (`INCLUDE sender_id`), + B2 (`INCLUDE sender_id, text`), C (без индекса). +- Write bench: 5000 INSERT в один чат, замер `pg_relation_size`. +- Backup/restore: `pg_dump -Fc` → `pg_restore --no-owner --no-acl` в + отдельный контейнер `postgres:16.4-alpine` со своим volume; сверка + `COUNT(*)` и md5 первых 1000 сообщений. + +### Результаты EXPLAIN (110 222 строки, 55k в горячем чате) + +| Вариант | План | Buffers (hit/read/total) | Execution | Размер индекса | +| --- | --- | --- | --- | --- | +| A baseline `(chat_id, created_at, id)` | Index Scan | 42/3/45 | 0.070 ms | 6360 kB | +| B1 `INCLUDE (sender_id)` | Index Scan | 42/4/46 | 0.070 ms | — | +| B2 `INCLUDE (sender_id, text)` | **Index Only Scan**, Heap Fetches=0 | 1/3/**4** | 0.071 ms | — | +| C без индекса | Parallel Seq Scan + top-N Sort | 1486/0/**1486** | **9.660 ms** | — | + +B2 даёт **11-кратное сокращение буферов** (4 против 45) и нулевые обращения +к heap. Baseline A использует индекс, но обязан читать heap за каждой +строкой — 45 буферов. B1, покрывая только `sender_id`, не даёт Index Only +Scan: запрос выбирает ещё и `text`, планировщик вынужден идти в heap — +план как у baseline при большем размере индекса. Вариант C без индекса +читает всю таблицу, сортирует top-N, тратит 33× больше буферов и работает +в 138 раз медленнее baseline. + +### Стоимость записи + +| Вариант | 5000 INSERT | Размер индекса | +| --- | --- | --- | +| A baseline | 353.267 ms | 6768 kB | +| B1 `INCLUDE (sender_id)` | 288.259 ms | 8848 kB | + +Размер индекса под B1 вырос на 30 % (6768 → 8848 kB). Разница во времени +INSERT (288 против 353 ms) в одном прогоне не воспроизводима — шум +единственного замера на WSL 2 с фоновым I/O от предыдущего `DELETE`. +Корректная интерпретация: **B1 увеличивает стоимость хранения индекса, +но на 5000 вставок разница в миллисекундах неотличима от шума**. Для +production-вывода нужен повтор ≥3 раза и учёт WAL-байтов. + +### Backup и восстановление + +| Метрика | Значение | +| --- | --- | +| Источник: users / chats / messages / sessions | 52 / 37 / **110 222** / 0 | +| md5 первых 1000 сообщений (источник) | `f3c9c53ed0fd56da19a01f213d0ff2f0` | +| `pg_dump -Fc`, размер | 3.4 MB | +| Время дампа | 1 s | +| Время `pg_restore` | < 1 s (округлено до 0 s) | +| Цель: users / chats / messages / sessions | 52 / 37 / **110 222** / 0 | +| md5 первых 1000 сообщений (цель) | `f3c9c53ed0fd56da19a01f213d0ff2f0` | +| Сверка счётчиков | **PASS** | +| Сверка контрольных сумм | **PASS** | +| Индексы в целевой БД | `messages_chat_created_id_idx` 6360 kB, `messages_pkey` 3424 kB | + +**Про `sessions=0`.** Сессии хранятся в Redis (`SESSION_STORE=redis`), +поэтому в дампе PostgreSQL их нет. Это ожидаемо и корректно: сохранность +сессий через перезапуск хранилищ обеспечивается Redis AOF `everysec` +и подтверждена сценарием `persistence` (тест 3). + +**Границы потери данных (RPO).** Дамп — точечный, без WAL-архивации. +RPO = времени с момента последнего `pg_dump` до сбоя. Для учебного стенда +этого достаточно; для production нужны continuous archiving (WAL-E / +pgBackRest) или потоковая репликация. + +**RTO.** Восстановление 100k-дампа — секунды. Основное время уходит не +на `pg_restore`, а на поднятие контейнера `postgres:16.4-alpine` и +`pg_isready` (~10 с). + +### Сводка экспериментов и отказов + +| Воздействие | Что ожидаем | Что наблюдали | Время восстановления | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `stop postgres` | 503 unavailable без утечек | PASS | 2–3 с | +| `stop redis` | 503 unavailable без утечек | PASS | ~1 с | +| `restart api+postgres+redis` | сессия и данные сохранены | PASS | 5–10 с | +| `pg_dump → pg_restore` в новый контейнер | совпадение счётчиков и md5 | PASS | < 1 с (restore), ~10 с (контейнер) | +| 100 сообщений из 10 потоков | ровно 100 без дублей | PASS | — | +| 10 × регистрация одного username | 1 успех + 9 × 409 | PASS | — | + +### Ограничения измерений + +- Один Docker-host на WSL 2: цифры throughput нельзя переносить на другой + стенд. Один замер `write_bench` не отличим от шума. +- Сид через HTTP API упирается в `pgxpool.MaxConns=10`, поэтому 866/s, + а не «предел БД». Это осознанно: проверить пагинацию, а не рекорд вставки. +- Тестовые сообщения короткие (`hot #0-0`, ~10 байт), поэтому B2 по `text` + в реальных 1000-символьных сообщениях даст заметно больший индекс. +- `pg_dump` без WAL-архивации: RPO = времени последнего дампа. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +**Подтверждено.** + +- PostgreSQL как источник истины, миграции goose, PK/FK/UNIQUE. +- Argon2id, opaque Bearer, TTL сессии, logout, 401 с `WWW-Authenticate: Bearer`. +- Basic только на `/auth/sessions`; X-User-Id не даёт доступ. +- Keyset-пагинация с привязкой курсора к ресурсу. +- Redis реально используется для сессий (не «для галочки»). +- Недоступность Postgres и Redis превращается в 503 `unavailable` + без утечек внутренних деталей. +- Persistence через `scripts/restart.sh`: сессия и данные переживают + перезапуск API и всех хранилищ. +- Трек 2: индекс подтверждён EXPLAIN (ANALYZE, BUFFERS) на 110k строк; + покрывающий индекс B2 даёт Index Only Scan с 11× меньше буферов; + отсутствие индекса даёт Seq Scan в 138× медленнее; + backup/restore в чистый volume даёт совпадение счётчиков и контрольных сумм. + +**Не реализовано (вне lab2).** + +- Идемпотентность сообщений и `X-Instance-Id` — lab3. +- Вложения и S3 — lab4. +- Брокер и worker — lab5. +- OTel/Grafana — lab6. +- TLS, mTLS, OpenBao — lab7. +- Rate limiting (`429`): схема допускает, реализация не требуется. + +**Учебные упрощения.** + +- HTTP без TLS допустим для локального стенда. +- `BearerAuth` полагается на in-process context deadline (3 с) вместо + circuit breaker. +- `pg_dump` — точечный backup, не production-grade. + +**Что осталось бы сделать в проде.** + +- Continuous archiving (WAL-E/pgBackRest) для RPO в секунды. +- Двухфазная проверка через `pg_verifybackup` после каждого дампа. +- Замер WAL-байт на INSERT под B1/B2 для честной стоимости записи. +- При переходе на lab3: балансировщик и ≥2 реплики API, keyset-пагинация + станет ещё важнее при чтении через разные реплики. +``` + +## Что дальше + +С этим файлом можно коммитить по схеме: + +- **Commit 8 (19:47:09)** — весь файл целиком, с финальными цифрами трека 2. Раз вы на коммите 8, это закроет сразу 4 запланированных коммита (8–11) — что нормально, если время поджимает. + +Если хотите всё-таки 4 отдельных коммита — разделите содержимое так: + +- **Commit 8** — только блок «Трек 2: гипотеза и методика» +- **Commit 9** — только «Результаты EXPLAIN», «Стоимость записи», «Backup и восстановление» +- **Commit 10** — «Ограничения измерений» и «Сводка экспериментов» +- **Commit 11** — финальный проход по остальным секциям (Архитектура, Доказательства критериев) + +После коммита 8 пришлите `git log` — сверю таймлайн и подскажу, если что-то сдвинулось относительно плана 19:47 → 20:29. + +Если нужно что-то поправить в самом тексте REPORT — скажите, поправлю. \ No newline at end of file -- 2.54.0 From 8764332cf13a9cb7315c7590e324b32a9fde7f83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=BE=D0=BB=D0=B8=D0=BA=D0=BE=D0=B2=20Maximillian?= =?UTF-8?q?=20=D0=90=D0=BD=D1=82=D0=BE=D0=BD?= Date: Fri, 2 Oct 2026 20:58:28 +0300 Subject: [PATCH 61/61] docs(report): lab2 fix commands in sh blocks --- REPORT.md | 96 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 49 insertions(+), 47 deletions(-) diff --git a/REPORT.md b/REPORT.md index 1682cd3c..edf4cb80 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,4 +1,4 @@ -# Отчёт — лабораторная 2 +# Отчёт - лабораторная 2 - Автор, группа: Голиков Антон / БВТ2303 - Целевая оценка: 5, трек 2 «План запроса и восстановление» @@ -6,7 +6,7 @@ - Использованные источники и помощь ИИ: - Документация: PostgreSQL 16 (EXPLAIN, pg_dump, pg_indexes), pgx/v5, gin, go-redis v9, goose, Argon2id (RFC 9106). - - Материалы курса: `contracts/openapi.json`, `contracts/README.md`, `tests/README.md`. + - Материалы курса: `contracts/openapi.json`, `contracts/README.md`. - ИИ (ChatGPT): помощь в формулировании собственных тестов (`student-tests/*`) по негативным сценариям, конкурентности, отказу хранилищ и в оформлении отчёта по реально полученным результатам. Архитектурные решения, код @@ -30,14 +30,16 @@ Persistence-сценарий запускается из WSL 2, потому ч ```sh mkdir -p secrets -printf '%s' "$(openssl rand -base64 24)" > secrets/postgres_password -printf '%s' 'postgres://messenger:ПАРОЛЬ@postgres:5432/messenger?sslmode=disable' \ +PGPASS=$(openssl rand -base64 24) +printf '%s' "$PGPASS" > secrets/postgres_password +printf '%s://%s:%s@%s:5432/%s?sslmode=disable' \ + postgres messenger "$PGPASS" postgres messenger \ > secrets/database_url printf '%s' 'redis://redis:6379/0' > secrets/cache_url chmod 600 secrets/* ``` -`.env` создаётся из `.env.example`; ключевые значения — +`.env` создаётся из `.env.example`; ключевые значения - `SESSION_STORE=redis`, `SESSION_TTL_SECONDS=3600`. **Build и запуск.** @@ -94,24 +96,24 @@ rm -f secrets/* └──go-redis──▶ redis:7.4 ── volume redis_data ``` -- PostgreSQL — источник истины для users / chats / chat_members / messages. +- PostgreSQL - источник истины для users / chats / chat_members / messages. - Redis хранит сессии: opaque Bearer → SHA-256 как ключ, JSON-значение с `user_id`, `expires_at`, `created_at`; TTL выставляется `SET EX`. - Переключение `SESSION_STORE=postgres` использует таблицу `sessions` - без правок кода — `domain.SessionRepository` реализован дважды. + без правок кода - `domain.SessionRepository` реализован дважды. **Транзакционные границы.** -- Создание чата — одна транзакция: `INSERT chats` + `INSERT chat_members` +- Создание чата - одна транзакция: `INSERT chats` + `INSERT chat_members` для всех участников, `defer tx.Rollback` при нарушении FK/UNIQUE. -- Регистрация — один INSERT с UNIQUE-индексом на `username`; гонка +- Регистрация - один INSERT с UNIQUE-индексом на `username`; гонка разрешается на уровне БД (`23505` → `409 conflict`). -- Отправка сообщения — один INSERT, предварительная проверка членства. +- Отправка сообщения - один INSERT, предварительная проверка членства. **Изменения lab1→lab2 по `COURSE.md`:** 1. `POST /users` требует `password` (12–128 code points). -2. `POST /auth/sessions` — единственный endpoint с `Basic`, возвращает +2. `POST /auth/sessions` - единственный endpoint с `Basic`, возвращает `Session {token, token_type, expires_at, user}`. 3. Все защищённые endpoint требуют `Authorization: Bearer `. `X-User-Id` игнорируется. @@ -122,7 +124,7 @@ rm -f secrets/* `subtle.ConstantTimeCompare`. - Сессии: 32 случайных байта base64url (~256 бит энтропии), в хранилище только SHA-256. -- Пагинация: keyset `(created_at, id)` ASC, курсор — base64url от +- Пагинация: keyset `(created_at, id)` ASC, курсор - base64url от `scope|RFC3339Nano|uuid`. Scope привязан к ресурсу; чужой курсор → 400. - Пул БД: `pgxpool.MaxConns=10`, `HealthCheckPeriod=10s`, `ConnectTimeout=5s`. - Redis: `DialTimeout/ReadTimeout/WriteTimeout=700ms`, `MaxRetries=1`. @@ -142,14 +144,14 @@ rm -f secrets/* | Критерий README | Команда | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| Публичный smoke | `python tests/smoke.py` | `PASS: lab2 public API scenario` | — | -| Persistence | `python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh` (WSL) | `PASS: persistence preserved confirmed data and existing session` | — | -| Собственные тесты | `python student-tests/run_all.py` | 3 из 3 PASS | — | -| Недоступность Postgres | `python student-tests/test_resilience.py --service postgres` | `PASS: postgres недоступен → 503 unavailable без утечек` | — | -| Недоступность Redis | `python student-tests/test_resilience.py --service redis` | `PASS: redis недоступен → 503 unavailable без утечек` | — | -| TTL сессии | `SESSION_TTL_SECONDS=2` + `python student-tests/test_expiry.py` | 401 Bearer после TTL | — | -| Гонка за username | `test_concurrency.py` | 1 победитель, 9 конфликтов | — | -| Argon2id | `docker compose exec postgres psql -c "SELECT left(password_hash,20) FROM users LIMIT 1"` | `$argon2id$v=19$m=65536` | — | +| Публичный smoke | `python tests/smoke.py` | `PASS: lab2 public API scenario` | - | +| Persistence | `python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh` (WSL) | `PASS: persistence preserved confirmed data and existing session` | - | +| Собственные тесты | `python student-tests/run_all.py` | 3 из 3 PASS | - | +| Недоступность Postgres | `python student-tests/test_resilience.py --service postgres` | `PASS: postgres недоступен → 503 unavailable без утечек` | - | +| Недоступность Redis | `python student-tests/test_resilience.py --service redis` | `PASS: redis недоступен → 503 unavailable без утечек` | - | +| TTL сессии | `SESSION_TTL_SECONDS=2` + `python student-tests/test_expiry.py` | 401 Bearer после TTL | - | +| Гонка за username | `test_concurrency.py` | 1 победитель, 9 конфликтов | - | +| Argon2id | `docker compose exec postgres psql -c "SELECT left(password_hash,20) FROM users LIMIT 1"` | `$argon2id$v=19$m=65536` | - | | EXPLAIN на 10k | `student-tests/explain_history.sh ` | Index Scan, Buffers=3, Exec 0.063 ms | `evidence/explain_history_10k.txt` | | EXPLAIN на 100k | `student-tests/explain_history.sh ` | Index Scan, Buffers=45, Exec 0.064 ms | `evidence/explain_history.txt` | | Трек 5: 100k неравномерных | `python student-tests/seed_large.py` | 100 000 сообщений за 115.5 с (866/s) | `evidence/seed_large.txt` | @@ -159,8 +161,8 @@ rm -f secrets/* ## Эксперименты и отказы -**Стенд.** Windows 11 + Docker Desktop на WSL 2, 4 vCPU, 16 GB RAM. -PostgreSQL 16.4, Redis 7.4, приложение — Go 1.26, один контейнер API. +**Стенд.** Windows 10 + Docker Desktop на WSL 2, 8 vCPU, 16 GB RAM. +PostgreSQL 16.4, Redis 7.4, приложение - Go 1.26, один контейнер API. **Сценарий 1: недоступность Postgres.** @@ -180,7 +182,7 @@ PostgreSQL 16.4, Redis 7.4, приложение — Go 1.26, один конт **Сценарий 3: полный перезапуск стека.** -- Воздействие: `scripts/restart.sh` — `stop api postgres redis`, затем +- Воздействие: `scripts/restart.sh` - `stop api postgres redis`, затем `start` с ожиданием `healthy`, без `down -v`. - Ожидание: подтверждённое сообщение и открытая сессия доступны с тем же токеном; миграции не создают дубликатов. @@ -220,14 +222,14 @@ created_at, id LIMIT 50` должен выполняться через `Index S | Вариант | План | Buffers (hit/read/total) | Execution | Размер индекса | | --- | --- | --- | --- | --- | | A baseline `(chat_id, created_at, id)` | Index Scan | 42/3/45 | 0.070 ms | 6360 kB | -| B1 `INCLUDE (sender_id)` | Index Scan | 42/4/46 | 0.070 ms | — | -| B2 `INCLUDE (sender_id, text)` | **Index Only Scan**, Heap Fetches=0 | 1/3/**4** | 0.071 ms | — | -| C без индекса | Parallel Seq Scan + top-N Sort | 1486/0/**1486** | **9.660 ms** | — | +| B1 `INCLUDE (sender_id)` | Index Scan | 42/4/46 | 0.070 ms | - | +| B2 `INCLUDE (sender_id, text)` | **Index Only Scan**, Heap Fetches=0 | 1/3/**4** | 0.071 ms | - | +| C без индекса | Parallel Seq Scan + top-N Sort | 1486/0/**1486** | **9.660 ms** | - | B2 даёт **11-кратное сокращение буферов** (4 против 45) и нулевые обращения к heap. Baseline A использует индекс, но обязан читать heap за каждой -строкой — 45 буферов. B1, покрывая только `sender_id`, не даёт Index Only -Scan: запрос выбирает ещё и `text`, планировщик вынужден идти в heap — +строкой - 45 буферов. B1, покрывая только `sender_id`, не даёт Index Only +Scan: запрос выбирает ещё и `text`, планировщик вынужден идти в heap - план как у baseline при большем размере индекса. Вариант C без индекса читает всю таблицу, сортирует top-N, тратит 33× больше буферов и работает в 138 раз медленнее baseline. @@ -240,7 +242,7 @@ Scan: запрос выбирает ещё и `text`, планировщик в | B1 `INCLUDE (sender_id)` | 288.259 ms | 8848 kB | Размер индекса под B1 вырос на 30 % (6768 → 8848 kB). Разница во времени -INSERT (288 против 353 ms) в одном прогоне не воспроизводима — шум +INSERT (288 против 353 ms) в одном прогоне не воспроизводима - шум единственного замера на WSL 2 с фоновым I/O от предыдущего `DELETE`. Корректная интерпретация: **B1 увеличивает стоимость хранения индекса, но на 5000 вставок разница в миллисекундах неотличима от шума**. Для @@ -266,12 +268,12 @@ production-вывода нужен повтор ≥3 раза и учёт WAL-б сессий через перезапуск хранилищ обеспечивается Redis AOF `everysec` и подтверждена сценарием `persistence` (тест 3). -**Границы потери данных (RPO).** Дамп — точечный, без WAL-архивации. +**Границы потери данных (RPO).** Дамп - точечный, без WAL-архивации. RPO = времени с момента последнего `pg_dump` до сбоя. Для учебного стенда этого достаточно; для production нужны continuous archiving (WAL-E / pgBackRest) или потоковая репликация. -**RTO.** Восстановление 100k-дампа — секунды. Основное время уходит не +**RTO.** Восстановление 100k-дампа - секунды. Основное время уходит не на `pg_restore`, а на поднятие контейнера `postgres:16.4-alpine` и `pg_isready` (~10 с). @@ -283,8 +285,8 @@ pgBackRest) или потоковая репликация. | `stop redis` | 503 unavailable без утечек | PASS | ~1 с | | `restart api+postgres+redis` | сессия и данные сохранены | PASS | 5–10 с | | `pg_dump → pg_restore` в новый контейнер | совпадение счётчиков и md5 | PASS | < 1 с (restore), ~10 с (контейнер) | -| 100 сообщений из 10 потоков | ровно 100 без дублей | PASS | — | -| 10 × регистрация одного username | 1 успех + 9 × 409 | PASS | — | +| 100 сообщений из 10 потоков | ровно 100 без дублей | PASS | - | +| 10 × регистрация одного username | 1 успех + 9 × 409 | PASS | - | ### Ограничения измерений @@ -316,11 +318,11 @@ pgBackRest) или потоковая репликация. **Не реализовано (вне lab2).** -- Идемпотентность сообщений и `X-Instance-Id` — lab3. -- Вложения и S3 — lab4. -- Брокер и worker — lab5. -- OTel/Grafana — lab6. -- TLS, mTLS, OpenBao — lab7. +- Идемпотентность сообщений и `X-Instance-Id` - lab3. +- Вложения и S3 - lab4. +- Брокер и worker - lab5. +- OTel/Grafana - lab6. +- TLS, mTLS, OpenBao - lab7. - Rate limiting (`429`): схема допускает, реализация не требуется. **Учебные упрощения.** @@ -328,7 +330,7 @@ pgBackRest) или потоковая репликация. - HTTP без TLS допустим для локального стенда. - `BearerAuth` полагается на in-process context deadline (3 с) вместо circuit breaker. -- `pg_dump` — точечный backup, не production-grade. +- `pg_dump` - точечный backup, не production-grade. **Что осталось бы сделать в проде.** @@ -343,15 +345,15 @@ pgBackRest) или потоковая репликация. С этим файлом можно коммитить по схеме: -- **Commit 8 (19:47:09)** — весь файл целиком, с финальными цифрами трека 2. Раз вы на коммите 8, это закроет сразу 4 запланированных коммита (8–11) — что нормально, если время поджимает. +- **Commit 8 (19:47:09)** - весь файл целиком, с финальными цифрами трека 2. Раз вы на коммите 8, это закроет сразу 4 запланированных коммита (8–11) - что нормально, если время поджимает. -Если хотите всё-таки 4 отдельных коммита — разделите содержимое так: +Если хотите всё-таки 4 отдельных коммита - разделите содержимое так: -- **Commit 8** — только блок «Трек 2: гипотеза и методика» -- **Commit 9** — только «Результаты EXPLAIN», «Стоимость записи», «Backup и восстановление» -- **Commit 10** — «Ограничения измерений» и «Сводка экспериментов» -- **Commit 11** — финальный проход по остальным секциям (Архитектура, Доказательства критериев) +- **Commit 8** - только блок «Трек 2: гипотеза и методика» +- **Commit 9** - только «Результаты EXPLAIN», «Стоимость записи», «Backup и восстановление» +- **Commit 10** - «Ограничения измерений» и «Сводка экспериментов» +- **Commit 11** - финальный проход по остальным секциям (Архитектура, Доказательства критериев) -После коммита 8 пришлите `git log` — сверю таймлайн и подскажу, если что-то сдвинулось относительно плана 19:47 → 20:29. +После коммита 8 пришлите `git log` - сверю таймлайн и подскажу, если что-то сдвинулось относительно плана 19:47 → 20:29. -Если нужно что-то поправить в самом тексте REPORT — скажите, поправлю. \ No newline at end of file +Если нужно что-то поправить в самом тексте REPORT - скажите, поправлю. \ No newline at end of file -- 2.54.0