Перенос минимума из lab1

This commit is contained in:
2026-10-30 09:21:46 +03:00
parent 65003b6119
commit e70fd2bb61
12 changed files with 1606 additions and 11 deletions
+9
View File
@@ -18,3 +18,12 @@ __pycache__
node_modules
evidence
.DS_Store
bin
coverage
*.out
*.test
**/*_test.go
cmd/*_test.go
internal/api/*_test.go
internal/store/*_test.go
internal/config/*_test.go
+2 -6
View File
@@ -3,9 +3,5 @@
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# SIGTERM budget. Must stay within 1..10 seconds.
SHUTDOWN_TIMEOUT_SECONDS=8
+20
View File
@@ -0,0 +1,20 @@
FROM golang:1.25-bookworm AS build
WORKDIR /src
COPY go.mod ./
COPY cmd ./cmd
COPY internal ./internal
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
go build -trimpath -ldflags='-s -w' -o /out/messenger ./cmd/messenger \
&& chmod 755 /out/messenger
FROM gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab
COPY --from=build --chown=65532:65532 /out/messenger /messenger
USER 65532:65532
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab \
SHUTDOWN_TIMEOUT_SECONDS=8
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=3s --retries=3 \
CMD ["/messenger", "healthcheck"]
ENTRYPOINT ["/messenger"]
+4 -5
View File
@@ -4,10 +4,10 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-own
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes; test-own: Go tests"
check:
$(PYTHON) scripts/check_contract.py
@@ -21,6 +21,5 @@ test:
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-own:
go test ./...
+3
View File
@@ -0,0 +1,3 @@
module messenger
go 1.25.0
+312
View File
@@ -0,0 +1,312 @@
package api
import (
"net/http"
"strings"
"messenger/internal/store"
)
func (a *API) live(w http.ResponseWriter, _ *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (a *API) ready(w http.ResponseWriter, r *http.Request) {
if a.shutting.Load() {
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервер останавливается", 1)
return
}
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (a *API) route(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
switch {
case path == "/api/v1/users" && r.Method == http.MethodPost:
a.createUser(w, r)
case path == "/api/v1/users/me" && r.Method == http.MethodGet:
a.currentUser(w, r)
case path == "/api/v1/chats" && r.Method == http.MethodPost:
a.createChat(w, r)
case path == "/api/v1/chats" && r.Method == http.MethodGet:
a.listChats(w, r)
default:
chatID, messages, ok := splitChatPath(path)
if !ok {
if knownWrongMethod(path) {
a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0)
return
}
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
return
}
switch {
case !messages && r.Method == http.MethodGet:
a.getChat(w, r, chatID)
case messages && r.Method == http.MethodPost:
a.createMessage(w, r, chatID)
case messages && r.Method == http.MethodGet:
a.listMessages(w, r, chatID)
default:
a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0)
}
}
}
func knownWrongMethod(path string) bool {
switch path {
case "/api/v1/users", "/api/v1/users/me", "/api/v1/chats":
return true
default:
return false
}
}
func (a *API) createUser(w http.ResponseWriter, r *http.Request) {
var body struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
}
if !a.readJSON(w, r, &body) {
return
}
if !usernameRe.MatchString(body.Username) || !validText(body.DisplayName, 1, 100) {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные поля пользователя", 0)
return
}
user, err := a.store.CreateUser(body.Username, body.DisplayName)
if err == store.ErrConflict {
a.fail(w, r, http.StatusConflict, "conflict", "Имя пользователя уже занято", 0)
return
}
if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
writeJSON(w, http.StatusCreated, asUser(user))
}
func (a *API) currentUser(w http.ResponseWriter, r *http.Request) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
writeJSON(w, http.StatusOK, asUser(user))
}
func (a *API) createChat(w http.ResponseWriter, r *http.Request) {
caller, ok := a.authenticate(w, r)
if !ok {
return
}
var body struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
if !a.readJSON(w, r, &body) {
return
}
if !validText(body.Title, 1, 100) || len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные поля чата", 0)
return
}
ids := make([]string, len(body.MemberIDs))
seen := make(map[string]struct{}, len(body.MemberIDs))
callerIn := false
for i, raw := range body.MemberIDs {
id, ok := canonicalUUID(raw)
if !ok {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
return
}
if _, dup := seen[id]; dup {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
return
}
seen[id] = struct{}{}
if _, exists := a.store.User(id); !exists {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
return
}
if id == caller.ID {
callerIn = true
}
ids[i] = id
}
if !callerIn {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
return
}
chat, err := a.store.CreateChat(body.Title, ids, caller.ID)
switch err {
case nil:
writeJSON(w, http.StatusCreated, asChat(chat))
case store.ErrInvalid:
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
default:
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
}
}
func (a *API) listChats(w http.ResponseWriter, r *http.Request) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
limit, cur, ok := a.pageQuery(w, r, "chats:"+user.ID)
if !ok {
return
}
items, hasMore, err := a.store.ListChats(user.ID, cur, limit)
if err == store.ErrBadCursor {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
return
}
if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
out := make([]chatJSON, 0, len(items))
for _, c := range items {
out = append(out, asChat(c))
}
var next *string
if hasMore && len(items) > 0 {
last := items[len(items)-1]
encoded := encodeCursor(cursorPayload{Scope: "chats:" + user.ID, ID: last.ID, At: formatTime(last.CreatedAt)})
next = &encoded
}
writeJSON(w, http.StatusOK, chatPage{Items: out, NextCursor: next})
}
func (a *API) getChat(w http.ResponseWriter, r *http.Request, rawID string) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
id, ok := a.chatID(w, r, rawID)
if !ok {
return
}
chat, err := a.store.ChatFor(id, user.ID)
if err == store.ErrNotFound {
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
return
}
if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
writeJSON(w, http.StatusOK, asChat(chat))
}
func (a *API) createMessage(w http.ResponseWriter, r *http.Request, rawID string) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
id, ok := a.chatID(w, r, rawID)
if !ok {
return
}
if _, err := a.store.ChatFor(id, user.ID); err == store.ErrNotFound {
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
return
} else if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
var body struct {
Text string `json:"text"`
}
if !a.readJSON(w, r, &body) {
return
}
if !validText(body.Text, 1, 4000) {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный текст сообщения", 0)
return
}
msg, err := a.store.AddMessage(id, user.ID, body.Text)
switch err {
case nil:
writeJSON(w, http.StatusCreated, asMessage(msg))
case store.ErrNotFound:
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
default:
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
}
}
func (a *API) listMessages(w http.ResponseWriter, r *http.Request, rawID string) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
id, ok := a.chatID(w, r, rawID)
if !ok {
return
}
if _, err := a.store.ChatFor(id, user.ID); err == store.ErrNotFound {
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
return
} else if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
limit, cur, ok := a.pageQuery(w, r, "msg:"+id)
if !ok {
return
}
items, hasMore, err := a.store.ListMessages(id, user.ID, cur, limit)
if err == store.ErrBadCursor {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
return
}
if err == store.ErrNotFound {
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
return
}
if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
out := make([]messageJSON, 0, len(items))
for _, m := range items {
out = append(out, asMessage(m))
}
var next *string
if hasMore && len(items) > 0 {
last := items[len(items)-1]
encoded := encodeCursor(cursorPayload{Scope: "msg:" + id, ID: last.ID, At: formatTime(last.CreatedAt)})
next = &encoded
}
writeJSON(w, http.StatusOK, messagePage{Items: out, NextCursor: next})
}
func (a *API) chatID(w http.ResponseWriter, r *http.Request, raw string) (string, bool) {
id, ok := canonicalUUID(raw)
if !ok {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный идентификатор", 0)
return "", false
}
return id, true
}
func splitChatPath(path string) (id string, messages bool, ok bool) {
const prefix = "/api/v1/chats/"
if !strings.HasPrefix(path, prefix) {
return "", false, false
}
rest := strings.TrimPrefix(path, prefix)
if rest == "" || strings.Contains(rest, "/") && !strings.HasSuffix(rest, "/messages") {
return "", false, false
}
if strings.HasSuffix(rest, "/messages") {
id = strings.TrimSuffix(rest, "/messages")
if id == "" || strings.Contains(id, "/") {
return "", false, false
}
return id, true, true
}
return rest, false, true
}
+321
View File
@@ -0,0 +1,321 @@
package api
import (
"bytes"
"crypto/rand"
"encoding/base64"
"encoding/hex"
"encoding/json"
"io"
"net/http"
"reflect"
"regexp"
"strconv"
"strings"
"time"
"unicode/utf8"
"messenger/internal/store"
)
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
var uuidRe = regexp.MustCompile(`(?i)^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
var limitRe = regexp.MustCompile(`^[0-9]{1,3}$`)
var requestIDRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,64}$`)
type errorEnvelope struct {
Error errorObject `json:"error"`
}
type errorObject struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
type userJSON struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
}
type chatJSON struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}
type messageJSON struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt string `json:"created_at"`
}
type chatPage struct {
Items []chatJSON `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type messagePage struct {
Items []messageJSON `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type cursorPayload struct {
Scope string `json:"scope"`
ID string `json:"id"`
At string `json:"at"`
}
type statusWriter struct {
http.ResponseWriter
status int
wrote bool
}
func (s *statusWriter) WriteHeader(code int) {
if s.wrote {
return
}
s.status = code
s.wrote = true
s.ResponseWriter.WriteHeader(code)
}
func (s *statusWriter) Write(b []byte) (int, error) {
if !s.wrote {
s.WriteHeader(http.StatusOK)
}
return s.ResponseWriter.Write(b)
}
func (a *API) fail(w http.ResponseWriter, r *http.Request, status int, code, message string, retryAfter int) {
if retryAfter > 0 {
w.Header().Set("Retry-After", strconv.Itoa(retryAfter))
}
writeJSON(w, status, errorEnvelope{Error: errorObject{
Code: code,
Message: message,
RequestID: requestIDFrom(r),
}})
}
func writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(status)
enc := json.NewEncoder(w)
enc.SetEscapeHTML(false)
_ = enc.Encode(v)
}
func (a *API) readJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
media := ""
if ct := r.Header.Get("Content-Type"); ct != "" {
media = strings.TrimSpace(strings.Split(ct, ";")[0])
}
if !strings.EqualFold(media, "application/json") {
a.fail(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Нужен Content-Type application/json", 0)
return false
}
body, err := io.ReadAll(r.Body)
if err != nil || !utf8.Valid(body) || !decodeExactJSON(body, dst) {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный JSON", 0)
return false
}
return true
}
// decodeExactJSON принимает один JSON-объект: точные имена полей, без хвоста и без замены битого UTF-8.
func decodeExactJSON(body []byte, dst any) bool {
dec := json.NewDecoder(bytes.NewReader(body))
var fields map[string]json.RawMessage
if err := dec.Decode(&fields); err != nil || fields == nil {
return false
}
var trailing json.RawMessage
if err := dec.Decode(&trailing); err != io.EOF {
return false
}
allowed, ok := jsonFieldNames(dst)
if !ok {
return false
}
for name := range fields {
if _, ok := allowed[name]; !ok {
return false
}
}
return json.Unmarshal(body, dst) == nil
}
func jsonFieldNames(dst any) (map[string]struct{}, bool) {
t := reflect.TypeOf(dst)
if t == nil || t.Kind() != reflect.Pointer {
return nil, false
}
t = t.Elem()
if t.Kind() != reflect.Struct {
return nil, false
}
names := make(map[string]struct{}, t.NumField())
for i := 0; i < t.NumField(); i++ {
name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",")
if name == "" || name == "-" {
return nil, false
}
names[name] = struct{}{}
}
return names, true
}
func (a *API) authenticate(w http.ResponseWriter, r *http.Request) (store.User, bool) {
raw := strings.TrimSpace(r.Header.Get("X-User-Id"))
id, ok := canonicalUUID(raw)
if !ok {
a.fail(w, r, http.StatusUnauthorized, "unauthorized", "Нет действительной идентификации", 0)
return store.User{}, false
}
user, exists := a.store.User(id)
if !exists {
a.fail(w, r, http.StatusUnauthorized, "unauthorized", "Нет действительной идентификации", 0)
return store.User{}, false
}
return user, true
}
func (a *API) pageQuery(w http.ResponseWriter, r *http.Request, scope string) (int, *store.Cursor, bool) {
q := r.URL.Query()
limit := 50
if q.Has("limit") {
raw := q.Get("limit")
n, err := strconv.Atoi(raw)
if err != nil || !limitRe.MatchString(raw) || n < 1 || n > 100 {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный limit", 0)
return 0, nil, false
}
limit = n
}
if !q.Has("cursor") {
return limit, nil, true
}
raw := q.Get("cursor")
if raw == "" || len(raw) > 512 {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
return 0, nil, false
}
payload, err := decodeCursor(raw)
if err != nil || payload.Scope != scope || payload.ID == "" || payload.At == "" {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
return 0, nil, false
}
at, err := time.Parse("2006-01-02T15:04:05.000000Z", payload.At)
if err != nil {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
return 0, nil, false
}
id, ok := canonicalUUID(payload.ID)
if !ok {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
return 0, nil, false
}
return limit, &store.Cursor{ID: id, At: at}, true
}
func asUser(u store.User) userJSON {
return userJSON{
ID: u.ID,
Username: u.Username,
DisplayName: u.DisplayName,
CreatedAt: formatTime(u.CreatedAt),
}
}
func asChat(c store.Chat) chatJSON {
ids := c.MemberIDs
if ids == nil {
ids = []string{}
}
return chatJSON{
ID: c.ID,
Title: c.Title,
MemberIDs: ids,
CreatedAt: formatTime(c.CreatedAt),
}
}
func asMessage(m store.Message) messageJSON {
return messageJSON{
ID: m.ID,
ChatID: m.ChatID,
SenderID: m.SenderID,
Text: m.Text,
CreatedAt: formatTime(m.CreatedAt),
}
}
func formatTime(t time.Time) string {
return t.UTC().Format("2006-01-02T15:04:05.000000Z")
}
func canonicalUUID(s string) (string, bool) {
if !uuidRe.MatchString(s) {
return "", false
}
return strings.ToLower(s), true
}
func validText(s string, min, max int) bool {
if strings.TrimSpace(s) == "" {
return false
}
n := utf8.RuneCountInString(s)
return n >= min && n <= max
}
func requestID(r *http.Request) string {
incoming := strings.TrimSpace(r.Header.Get("X-Request-Id"))
if requestIDRe.MatchString(incoming) {
return incoming
}
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
return strconv.FormatInt(time.Now().UnixNano(), 36)
}
return hex.EncodeToString(b[:])
}
func encodeCursor(p cursorPayload) string {
raw, err := json.Marshal(p)
if err != nil {
return ""
}
return base64.RawURLEncoding.EncodeToString(raw)
}
func decodeCursor(s string) (cursorPayload, error) {
b, err := base64.RawURLEncoding.DecodeString(s)
if err != nil {
b, err = base64.URLEncoding.DecodeString(s)
if err != nil {
return cursorPayload{}, err
}
}
dec := json.NewDecoder(bytes.NewReader(b))
dec.DisallowUnknownFields()
var p cursorPayload
if err := dec.Decode(&p); err != nil {
return cursorPayload{}, err
}
var trailing json.RawMessage
if err := dec.Decode(&trailing); err != io.EOF {
if err == nil {
err = io.ErrUnexpectedEOF
}
return cursorPayload{}, err
}
return p, nil
}
+86
View File
@@ -0,0 +1,86 @@
package api
import (
"context"
"log/slog"
"net/http"
"sync/atomic"
"time"
"messenger/internal/store"
)
type ctxKey struct{}
type API struct {
store *store.Store
log *slog.Logger
shutting atomic.Bool
}
// Создает Api
func New(st *store.Store, log *slog.Logger) *API {
if log == nil {
log = slog.Default()
}
return &API{
store: st,
log: log,
}
}
// BeginShutdown переводит /health/ready в 503 и говорит новым бизнес-запросам
// отказать до закрытия слушателя. Уже принятые обработчики дорабатывают.
func (a *API) BeginShutdown() {
a.shutting.Store(true)
a.log.Info("shutdown started")
}
// Точка входа
func (a *API) ServeHTTP(w http.ResponseWriter, r *http.Request) {
sw := &statusWriter{ResponseWriter: w, status: http.StatusOK}
start := time.Now()
id := requestID(r)
sw.Header().Set("X-Request-Id", id)
r = r.WithContext(context.WithValue(r.Context(), ctxKey{}, id))
defer func() {
if p := recover(); p != nil {
a.log.Error("panic", "request_id", id)
if !sw.wrote {
a.fail(sw, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
}
}
a.log.Info("request",
"request_id", id,
"method", r.Method,
"path", r.URL.Path,
"status", sw.status,
"duration_ms", time.Since(start).Milliseconds(),
"bytes_in", r.ContentLength,
)
}()
switch {
case r.Method == http.MethodGet && r.URL.Path == "/health/live":
a.live(sw, r)
return
case r.Method == http.MethodGet && r.URL.Path == "/health/ready":
a.ready(sw, r)
return
}
if a.shutting.Load() {
a.fail(sw, r, http.StatusServiceUnavailable, "unavailable", "Сервер останавливается", 1)
return
}
a.route(sw, r)
}
func requestIDFrom(r *http.Request) string {
id, _ := r.Context().Value(ctxKey{}).(string)
if id == "" {
return "unknown"
}
return id
}
+409
View File
@@ -0,0 +1,409 @@
package api
import (
"bytes"
"encoding/base64"
"encoding/json"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"testing"
"messenger/internal/store"
)
func newServer(t *testing.T) (*httptest.Server, *API, *bytes.Buffer) {
t.Helper()
var logs bytes.Buffer
st := store.New()
application := New(st, slog.New(slog.NewJSONHandler(&logs, nil)))
srv := httptest.NewServer(application)
t.Cleanup(srv.Close)
return srv, application, &logs
}
func do(t *testing.T, method, url, user string, body any, raw []byte, contentType string) (int, http.Header, []byte) {
t.Helper()
var rdr io.Reader
if raw != nil {
rdr = bytes.NewReader(raw)
} else if body != nil {
b, err := json.Marshal(body)
if err != nil {
t.Fatal(err)
}
rdr = bytes.NewReader(b)
}
req, err := http.NewRequest(method, url, rdr)
if err != nil {
t.Fatal(err)
}
if body != nil || raw != nil {
if contentType == "" {
contentType = "application/json"
}
req.Header.Set("Content-Type", contentType)
}
if user != "" {
req.Header.Set("X-User-Id", user)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
if resp.Header.Get("X-Request-Id") == "" {
t.Fatalf("%s %s: missing X-Request-Id", method, url)
}
if resp.StatusCode >= 400 {
var env errorEnvelope
if err := json.Unmarshal(data, &env); err != nil {
t.Fatalf("error json: %v body %s", err, data)
}
if env.Error.RequestID != resp.Header.Get("X-Request-Id") || env.Error.Code == "" || env.Error.Message == "" {
t.Fatalf("bad error envelope: %+v", env)
}
}
return resp.StatusCode, resp.Header, data
}
func createUser(t *testing.T, base, username, display string) userJSON {
t.Helper()
status, _, body := do(t, http.MethodPost, base+"/api/v1/users", "", map[string]string{
"username": username, "display_name": display,
}, nil, "")
if status != http.StatusCreated {
t.Fatalf("create user %s: %d %s", username, status, body)
}
var u userJSON
if err := json.Unmarshal(body, &u); err != nil {
t.Fatal(err)
}
return u
}
func createChat(t *testing.T, base, caller, title string, members ...string) chatJSON {
t.Helper()
status, _, body := do(t, http.MethodPost, base+"/api/v1/chats", caller, map[string]any{
"title": title, "member_ids": members,
}, nil, "")
if status != http.StatusCreated {
t.Fatalf("create chat: %d %s", status, body)
}
var c chatJSON
if err := json.Unmarshal(body, &c); err != nil {
t.Fatal(err)
}
return c
}
func TestInvalidJSONExtraFieldAndTypes(t *testing.T) {
srv, _, _ := newServer(t)
cases := [][]byte{
[]byte(`{`),
[]byte(`{"username":"abc","display_name":"Алиса","extra":1}`),
[]byte(`{"username":1,"display_name":"Алиса"}`),
[]byte(`null`),
}
for _, raw := range cases {
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/users", "", nil, raw, "application/json")
if status != http.StatusBadRequest || !bytes.Contains(body, []byte(`"invalid_request"`)) {
t.Fatalf("body %s: %d %s", raw, status, body)
}
}
status, _, _ := do(t, http.MethodPost, srv.URL+"/api/v1/users", "", nil, []byte(`{"username":"abc","display_name":"Алиса"}`), "text/plain")
if status != http.StatusUnsupportedMediaType {
t.Fatalf("content type: %d", status)
}
}
func TestStrictJSONNamesUTF8AndCursorTail(t *testing.T) {
srv, _, _ := newServer(t)
bad := [][]byte{
[]byte(`{"username":"bad_json","display_name":"Я"}]`),
[]byte(`{"username":"bad_json","display_name":"Я"}}`),
[]byte(`{"Username":"bad_case","display_name":"Я"}`),
append([]byte(`{"username":"bad_utf","display_name":"`), 0xff, '"', '}'),
}
for _, raw := range bad {
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/users", "", nil, raw, "application/json")
if status != http.StatusBadRequest {
t.Fatalf("user body %q: %d %s", raw, status, body)
}
}
alice := createUser(t, srv.URL, "alice", "Алиса")
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/chats", alice.ID, nil, []byte(`{"Title":"чат","member_ids":["`+alice.ID+`"]}`), "application/json")
if status != http.StatusBadRequest {
t.Fatalf("Title: %d %s", status, body)
}
chat := createChat(t, srv.URL, alice.ID, "чат", alice.ID)
status, _, body = do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, nil, []byte(`{"TEXT":"hi"}`), "application/json")
if status != http.StatusBadRequest {
t.Fatalf("TEXT: %d %s", status, body)
}
rawText := append([]byte(`{"text":"`), 0xff, '"', '}')
status, _, body = do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, nil, rawText, "application/json")
if status != http.StatusBadRequest {
t.Fatalf("message utf-8: %d %s", status, body)
}
status, _, body = do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "one"}, nil, "")
if status != http.StatusCreated {
t.Fatalf("seed: %d %s", status, body)
}
status, _, body = do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "two"}, nil, "")
if status != http.StatusCreated {
t.Fatalf("seed2: %d %s", status, body)
}
status, _, body = do(t, http.MethodGet, srv.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1", alice.ID, nil, nil, "")
if status != http.StatusOK {
t.Fatalf("page: %d %s", status, body)
}
var page messagePage
if err := json.Unmarshal(body, &page); err != nil || page.NextCursor == nil {
t.Fatalf("cursor: %v %s", err, body)
}
decoded, err := base64.RawURLEncoding.DecodeString(*page.NextCursor)
if err != nil {
t.Fatal(err)
}
tampered := base64.RawURLEncoding.EncodeToString(append(decoded, []byte("garbage")...))
status, _, body = do(t, http.MethodGet, srv.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1&cursor="+url.QueryEscape(tampered), alice.ID, nil, nil, "")
if status != http.StatusBadRequest {
t.Fatalf("tampered cursor: %d %s", status, body)
}
status, _, _ = do(t, http.MethodGet, srv.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1&cursor="+url.QueryEscape(*page.NextCursor), alice.ID, nil, nil, "")
if status != http.StatusOK {
t.Fatalf("valid cursor: %d", status)
}
}
func TestDuplicateUsername(t *testing.T) {
srv, _, _ := newServer(t)
createUser(t, srv.URL, "alice", "Алиса")
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/users", "", map[string]string{
"username": "alice", "display_name": "Другая",
}, nil, "")
if status != http.StatusConflict || !bytes.Contains(body, []byte(`"conflict"`)) {
t.Fatalf("duplicate: %d %s", status, body)
}
}
func TestEmptyMessageForeignChatAndAuth(t *testing.T) {
srv, _, _ := newServer(t)
alice := createUser(t, srv.URL, "alice", "Алиса")
bob := createUser(t, srv.URL, "bob", "Боб")
eve := createUser(t, srv.URL, "eve", "Ева")
chat := createChat(t, srv.URL, alice.ID, "Контрактный тест", alice.ID, bob.ID)
status, _, _ := do(t, http.MethodGet, srv.URL+"/api/v1/users/me", "", nil, nil, "")
if status != http.StatusUnauthorized {
t.Fatalf("missing header: %d", status)
}
status, _, _ = do(t, http.MethodGet, srv.URL+"/api/v1/users/me", "11111111-1111-4111-8111-111111111111", nil, nil, "")
if status != http.StatusUnauthorized {
t.Fatalf("unknown user: %d", status)
}
meStatus, _, meBody := do(t, http.MethodGet, srv.URL+"/api/v1/users/me", alice.ID, nil, nil, "")
if meStatus != http.StatusOK || !bytes.Contains(meBody, []byte(alice.ID)) {
t.Fatalf("me: %d %s", meStatus, meBody)
}
status, _, _ = do(t, http.MethodGet, srv.URL+"/api/v1/chats/"+chat.ID, eve.ID, nil, nil, "")
if status != http.StatusNotFound {
t.Fatalf("foreign chat: %d", status)
}
status, _, _ = do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", eve.ID, map[string]string{"text": "чужое"}, nil, "")
if status != http.StatusNotFound {
t.Fatalf("foreign post: %d", status)
}
for _, text := range []string{"", " ", "\n\t"} {
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": text}, nil, "")
if status != http.StatusBadRequest {
t.Fatalf("empty %q: %d %s", text, status, body)
}
}
status, _, _ = do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "привет", "sender_id": eve.ID}, nil, "")
if status != http.StatusBadRequest {
t.Fatalf("sender_id must be rejected: %d", status)
}
text := "Привет, мир 👋"
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": text}, nil, "")
if status != http.StatusCreated {
t.Fatalf("unicode: %d %s", status, body)
}
var msg messageJSON
if err := json.Unmarshal(body, &msg); err != nil {
t.Fatal(err)
}
if msg.Text != text || msg.SenderID != alice.ID || msg.ChatID != chat.ID {
t.Fatalf("message mutated: %+v", msg)
}
if !strings.HasSuffix(msg.CreatedAt, "Z") {
t.Fatalf("timestamp: %s", msg.CreatedAt)
}
}
func TestPaginationSeveralPages(t *testing.T) {
srv, _, _ := newServer(t)
alice := createUser(t, srv.URL, "alice", "Алиса")
bob := createUser(t, srv.URL, "bob", "Боб")
chat := createChat(t, srv.URL, alice.ID, "страницы", alice.ID, bob.ID)
other := createChat(t, srv.URL, alice.ID, "другой", alice.ID)
const n = 25
ids := make([]string, 0, n)
for i := 0; i < n; i++ {
sender := alice.ID
if i%2 == 1 {
sender = bob.ID
}
status, _, body := do(t, http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", sender, map[string]string{
"text": "сообщение " + strings.Repeat("я", i%3) + string(rune('a'+i%26)),
}, nil, "")
if status != http.StatusCreated {
t.Fatalf("post %d: %d %s", i, status, body)
}
var msg messageJSON
if err := json.Unmarshal(body, &msg); err != nil {
t.Fatal(err)
}
ids = append(ids, msg.ID)
}
var got []string
cursor := ""
pages := 0
for {
pages++
if pages > 10 {
t.Fatal("pagination did not finish")
}
url := srv.URL + "/api/v1/chats/" + chat.ID + "/messages?limit=10"
if cursor != "" {
url += "&cursor=" + cursor
}
status, _, body := do(t, http.MethodGet, url, bob.ID, nil, nil, "")
if status != http.StatusOK {
t.Fatalf("page: %d %s", status, body)
}
var page messagePage
if err := json.Unmarshal(body, &page); err != nil {
t.Fatal(err)
}
if len(page.Items) == 0 || len(page.Items) > 10 {
t.Fatalf("page size %d", len(page.Items))
}
for _, item := range page.Items {
got = append(got, item.ID)
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
if pages < 3 {
t.Fatalf("expected several pages, got %d", pages)
}
if strings.Join(got, ",") != strings.Join(ids, ",") {
t.Fatalf("order/duplication mismatch\nwant %v\ngot %v", ids, got)
}
status, _, _ := do(t, http.MethodGet, srv.URL+"/api/v1/chats/"+other.ID+"/messages?limit=10&cursor="+cursor, alice.ID, nil, nil, "")
if status != http.StatusBadRequest {
t.Fatalf("foreign cursor: %d", status)
}
status, _, _ = do(t, http.MethodGet, srv.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=0", alice.ID, nil, nil, "")
if status != http.StatusBadRequest {
t.Fatalf("limit 0: %d", status)
}
}
func TestConcurrentHundredMessages(t *testing.T) {
srv, _, _ := newServer(t)
users := make([]userJSON, 10)
ids := make([]string, 10)
for i := 0; i < 10; i++ {
users[i] = createUser(t, srv.URL, "u"+string(rune('a'+i))+"x", "Участник")
ids[i] = users[i].ID
}
chat := createChat(t, srv.URL, ids[0], "гонка", ids...)
var wg sync.WaitGroup
errCh := make(chan error, 100)
for i := 0; i < 10; i++ {
wg.Add(1)
go func(user string) {
defer wg.Done()
for j := 0; j < 10; j++ {
req, err := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/chats/"+chat.ID+"/messages", strings.NewReader(`{"text":"n"}`))
if err != nil {
errCh <- err
return
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-User-Id", user)
resp, err := http.DefaultClient.Do(req)
if err != nil {
errCh <- err
return
}
body, _ := io.ReadAll(resp.Body)
resp.Body.Close()
if resp.StatusCode != http.StatusCreated {
errCh <- &statusErr{resp.StatusCode, body}
}
}
}(ids[i])
}
wg.Wait()
close(errCh)
for err := range errCh {
t.Fatal(err)
}
seen := map[string]struct{}{}
cursor := ""
for {
url := srv.URL + "/api/v1/chats/" + chat.ID + "/messages?limit=17"
if cursor != "" {
url += "&cursor=" + cursor
}
status, _, body := do(t, http.MethodGet, url, ids[3], nil, nil, "")
if status != http.StatusOK {
t.Fatalf("list: %d %s", status, body)
}
var page messagePage
if err := json.Unmarshal(body, &page); err != nil {
t.Fatal(err)
}
for _, item := range page.Items {
if _, ok := seen[item.ID]; ok {
t.Fatalf("duplicate %s", item.ID)
}
seen[item.ID] = struct{}{}
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
if len(seen) != 100 {
t.Fatalf("unique messages = %d, want 100", len(seen))
}
}
type statusErr struct {
code int
body []byte
}
func (e *statusErr) Error() string {
return http.StatusText(e.code) + " " + string(e.body)
}
+67
View File
@@ -0,0 +1,67 @@
package config
import (
"fmt"
"net"
"os"
"strconv"
"time"
)
// Config - параметры процесса.
type Config struct {
Host string
Port string
Env string
ShutdownTimeout time.Duration
}
// Addr — адрес прослушивания. В контейнере это 0.0.0.0:8080,
// иначе published port Docker не попадёт в процесс.
func (c Config) Addr() string {
return net.JoinHostPort(c.Host, c.Port)
}
// Load завершает запуск ошибкой, если значение вне допустимого диапазона.
func Load() (Config, error) {
var c Config
c.Host = getenv("APP_HOST", "0.0.0.0")
c.Port = getenv("APP_PORT", "8080")
c.Env = getenv("APP_ENV", "lab")
if c.Host == "" {
return Config{}, fmt.Errorf("APP_HOST is empty")
}
port, err := strconv.Atoi(c.Port)
if err != nil || port < 1 || port > 65535 {
return Config{}, fmt.Errorf("APP_PORT must be 1..65535")
}
sec, err := nonNeg("SHUTDOWN_TIMEOUT_SECONDS", 8)
if err != nil {
return Config{}, err
}
if sec < 1 || sec > 10 {
return Config{}, fmt.Errorf("SHUTDOWN_TIMEOUT_SECONDS must be 1..10")
}
c.ShutdownTimeout = time.Duration(sec) * time.Second
return c, nil
}
func getenv(key, def string) string {
if v, ok := os.LookupEnv(key); ok && v != "" {
return v
}
return def
}
func nonNeg(key string, def int) (int, error) {
v, ok := os.LookupEnv(key)
if !ok || v == "" {
return def, nil
}
n, err := strconv.Atoi(v)
if err != nil || n < 0 {
return 0, fmt.Errorf("%s must be a non-negative integer", key)
}
return n, nil
}
+267
View File
@@ -0,0 +1,267 @@
package store
import (
"crypto/rand"
"encoding/hex"
"errors"
"sync"
"time"
)
var (
ErrConflict = errors.New("conflict")
ErrNotFound = errors.New("not found")
ErrInvalid = errors.New("invalid")
ErrBadCursor = errors.New("bad cursor")
)
// User - публичная карточка.
type User struct {
ID string
Username string
DisplayName string
CreatedAt time.Time
}
// Chat - неизменяемый состав участников.
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
// Message - подтверждённое сообщение. Текст после записи не меняется.
type Message struct {
ID string
ChatID string
SenderID string
Text string
CreatedAt time.Time
}
// Cursor - позиция keyset (created_at, id), уже проверенная вызывающим слоем
// на принадлежность ресурсу. Пустые поля означают первую страницу.
type Cursor struct {
ID string
At time.Time
}
type chatRec struct {
chat Chat
members map[string]struct{}
}
// Store сериализует записи мьютексом. Чтения берут RLock и копируют срез,
// поэтому параллельные запросы не делят изменяемый буфер.
type Store struct {
mu sync.RWMutex
users map[string]User
byName map[string]string
chats map[string]*chatRec
chatOrder []string
messages map[string][]Message
msgIndex map[string]map[string]int
last time.Time
}
func New() *Store {
return &Store{
users: make(map[string]User),
byName: make(map[string]string),
chats: make(map[string]*chatRec),
messages: make(map[string][]Message),
msgIndex: make(map[string]map[string]int),
}
}
func (s *Store) CreateUser(username, displayName string) (User, error) {
s.mu.Lock()
defer s.mu.Unlock()
if _, ok := s.byName[username]; ok {
return User{}, ErrConflict
}
u := User{
ID: newID(),
Username: username,
DisplayName: displayName,
CreatedAt: s.nextTimeLocked(),
}
s.users[u.ID] = u
s.byName[username] = u.ID
return u, nil
}
func (s *Store) User(id string) (User, bool) {
s.mu.RLock()
defer s.mu.RUnlock()
u, ok := s.users[id]
return u, ok
}
func (s *Store) CreateChat(title string, memberIDs []string, caller string) (Chat, error) {
s.mu.Lock()
defer s.mu.Unlock()
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return Chat{}, ErrInvalid
}
seen[id] = struct{}{}
if _, ok := s.users[id]; !ok {
return Chat{}, ErrInvalid
}
}
if _, ok := seen[caller]; !ok {
return Chat{}, ErrInvalid
}
c := Chat{
ID: newID(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...),
CreatedAt: s.nextTimeLocked(),
}
s.chats[c.ID] = &chatRec{chat: c, members: seen}
s.chatOrder = append(s.chatOrder, c.ID)
s.messages[c.ID] = nil
s.msgIndex[c.ID] = make(map[string]int)
return c, nil
}
func (s *Store) ChatFor(chatID, userID string) (Chat, error) {
s.mu.RLock()
defer s.mu.RUnlock()
rec, ok := s.chats[chatID]
if !ok {
return Chat{}, ErrNotFound
}
if _, member := rec.members[userID]; !member {
return Chat{}, ErrNotFound
}
return rec.chat.clone(), nil
}
func (s *Store) ListChats(userID string, cur *Cursor, limit int) ([]Chat, bool, error) {
s.mu.RLock()
defer s.mu.RUnlock()
filtered := make([]Chat, 0)
for _, id := range s.chatOrder {
rec := s.chats[id]
if _, ok := rec.members[userID]; ok {
filtered = append(filtered, rec.chat.clone())
}
}
start, err := indexAfter(filtered, cur, func(c Chat) (string, time.Time) {
return c.ID, c.CreatedAt
})
if err != nil {
return nil, false, err
}
end := start + limit
if end > len(filtered) {
end = len(filtered)
}
return append([]Chat(nil), filtered[start:end]...), end < len(filtered), nil
}
func (s *Store) AddMessage(chatID, senderID, text string) (Message, error) {
s.mu.Lock()
defer s.mu.Unlock()
rec, ok := s.chats[chatID]
if !ok {
return Message{}, ErrNotFound
}
if _, member := rec.members[senderID]; !member {
return Message{}, ErrNotFound
}
m := Message{
ID: newID(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: s.nextTimeLocked(),
}
idx := len(s.messages[chatID])
s.messages[chatID] = append(s.messages[chatID], m)
s.msgIndex[chatID][m.ID] = idx
return m, nil
}
func (s *Store) ListMessages(chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) {
s.mu.RLock()
defer s.mu.RUnlock()
rec, ok := s.chats[chatID]
if !ok {
return nil, false, ErrNotFound
}
if _, member := rec.members[userID]; !member {
return nil, false, ErrNotFound
}
all := s.messages[chatID]
start := 0
if cur != nil {
idx, ok := s.msgIndex[chatID][cur.ID]
if !ok || !all[idx].CreatedAt.Equal(cur.At) {
return nil, false, ErrBadCursor
}
start = idx + 1
}
end := start + limit
if end > len(all) {
end = len(all)
}
// Копия значений: вызывающий не удерживает внутренний срез.
out := append([]Message(nil), all[start:end]...)
return out, end < len(all), nil
}
// nextTimeLocked выдаёт неубывающее время фиксации.
func (s *Store) nextTimeLocked() time.Time {
now := time.Now().UTC().Truncate(time.Microsecond)
if !now.After(s.last) {
now = s.last.Add(time.Microsecond)
}
s.last = now
return now
}
func indexAfter[T any](items []T, cur *Cursor, key func(T) (string, time.Time)) (int, error) {
if cur == nil {
return 0, nil
}
for i, item := range items {
id, at := key(item)
if id == cur.ID {
if !at.Equal(cur.At) {
return 0, ErrBadCursor
}
return i + 1, nil
}
}
return 0, ErrBadCursor
}
func (c Chat) clone() Chat {
c.MemberIDs = append([]string(nil), c.MemberIDs...)
return c
}
func newID() string {
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
panic("crypto/rand: " + err.Error())
}
b[6] = (b[6] & 0x0f) | 0x40
b[8] = (b[8] & 0x3f) | 0x80
var buf [36]byte
hex.Encode(buf[0:8], b[0:4])
buf[8] = '-'
hex.Encode(buf[9:13], b[4:6])
buf[13] = '-'
hex.Encode(buf[14:18], b[6:8])
buf[18] = '-'
hex.Encode(buf[19:23], b[8:10])
buf[23] = '-'
hex.Encode(buf[24:36], b[10:16])
return string(buf[:])
}
+106
View File
@@ -0,0 +1,106 @@
package main
import (
"context"
"errors"
"io"
"log/slog"
"net"
"net/http"
"os"
"os/signal"
"strconv"
"syscall"
"time"
"messenger/internal/api"
"messenger/internal/config"
"messenger/internal/store"
)
func main() {
if len(os.Args) > 1 && os.Args[1] == "healthcheck" {
os.Exit(runHealthcheck())
}
// Инициализация
cfg, err := config.Load()
if err != nil {
slog.Error("config", "err", err.Error())
os.Exit(2)
}
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
st := store.New()
application := api.New(st, log)
// http сервер
srv := &http.Server{
Addr: cfg.Addr(),
Handler: application,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
MaxHeaderBytes: 1 << 20,
}
// Запуск сервера
errCh := make(chan error, 1)
go func() {
log.Info("listening",
"addr", cfg.Addr(),
"env", cfg.Env,
"shutdown_timeout_seconds", int(cfg.ShutdownTimeout/time.Second),
)
err := srv.ListenAndServe()
if err != nil && !errors.Is(err, http.ErrServerClosed) {
errCh <- err
}
close(errCh)
}()
// Ожидание сигнала или ошибки
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT)
select {
case err := <-errCh:
log.Error("server", "err", err.Error())
os.Exit(1)
case <-sig:
}
// Плавное завершение
application.BeginShutdown()
ctx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
log.Error("shutdown timeout, closing listener", "err", err.Error())
_ = srv.Close()
}
log.Info("shutdown complete")
}
func runHealthcheck() int {
port := os.Getenv("APP_PORT")
if port == "" {
port = "8080"
}
n, err := strconv.Atoi(port)
if err != nil || n < 1 || n > 65535 {
return 1
}
client := http.Client{Timeout: 2 * time.Second}
req, err := http.NewRequest(http.MethodGet, "http://"+net.JoinHostPort("127.0.0.1", port)+"/health/ready", nil)
if err != nil {
return 1
}
resp, err := client.Do(req)
if err != nil {
return 1
}
defer resp.Body.Close()
_, _ = io.Copy(io.Discard, resp.Body)
if resp.StatusCode != http.StatusOK {
return 1
}
return 0
}