Files
mtusi2026lab2/main.go
T

572 lines
18 KiB
Go

package main
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"net"
"net/http"
"os"
"os/signal"
"regexp"
"strconv"
"strings"
"sync/atomic"
"syscall"
"time"
"unicode/utf8"
"github.com/lib/pq"
"github.com/redis/go-redis/v9"
"mtusi2026lab2/models"
)
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
var uuidPattern = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
type cacheMetrics struct{ hits, misses, failures atomic.Uint64 }
type app struct {
store *store
limits limits
metrics metrics
cacheMetrics cacheMetrics
gate, kdfGate chan struct{}
ttl time.Duration
timeout time.Duration
dummyHash string
}
type createUser struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
type createChat struct {
Title string `json:"title"`
MemberIDs []models.UUID `json:"member_ids"`
}
type createMessage struct {
Text string `json:"text"`
}
type cursor struct {
Resource string `json:"resource"`
CreatedAt time.Time `json:"created_at"`
ID models.UUID `json:"id"`
}
func setting(name, fallback string) string {
if value := os.Getenv(name); value != "" {
return value
}
return fallback
}
func secret(name string) string {
if path := os.Getenv(name + "_FILE"); path != "" {
data, err := os.ReadFile(path)
if err != nil {
log.Fatalf("cannot read %s_FILE", name)
}
return strings.TrimSpace(string(data))
}
return os.Getenv(name)
}
func main() {
if setting("SESSION_STORE", "postgres") != "postgres" {
log.Fatal("this implementation uses PostgreSQL sessions")
}
db, err := sql.Open("postgres", secret("DATABASE_URL"))
if err != nil {
log.Fatal("invalid database configuration")
}
defer db.Close()
pool := envInt("DB_MAX_CONNECTIONS", 8, 1)
db.SetMaxOpenConns(pool)
db.SetMaxIdleConns(pool)
db.SetConnMaxLifetime(30 * time.Minute)
bootCtx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
if err = migrate(bootCtx, db); err != nil {
cancel()
log.Fatal("database migration failed: ", err)
}
cancel()
configuration := loadLimits()
a := &app{store: &store{db: db}, limits: configuration, gate: make(chan struct{}, configuration.maxInFlight), kdfGate: make(chan struct{}, envInt("KDF_CONCURRENCY", 4, 1)), ttl: time.Duration(envInt("SESSION_TTL_SECONDS", 3600, 1)) * time.Second, timeout: time.Duration(envInt("DB_TIMEOUT_MS", 2000, 100)) * time.Millisecond, dummyHash: hashPassword("dummy-never-a-login-password")}
if url := secret("CACHE_URL"); url != "" {
options, err := redis.ParseURL(url)
if err != nil {
log.Fatal("invalid cache configuration")
}
options.PoolSize = pool
options.MaxRetries = -1
options.DialTimeout = 150 * time.Millisecond
options.ReadTimeout = 150 * time.Millisecond
options.WriteTimeout = 150 * time.Millisecond
options.PoolTimeout = 150 * time.Millisecond
options.ContextTimeoutEnabled = true
a.store.cache = redis.NewClient(options)
a.store.metrics = &a.cacheMetrics
defer a.store.cache.Close()
}
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
go func() {
ticker := time.NewTicker(time.Minute)
defer ticker.Stop()
for {
select {
case <-rootCtx.Done():
return
case <-ticker.C:
ctx, cancel := context.WithTimeout(rootCtx, a.timeout)
_, _ = db.ExecContext(ctx, `DELETE FROM sessions WHERE expires_at<=clock_timestamp()`)
cancel()
}
}
}()
server := &http.Server{Addr: net.JoinHostPort(setting("APP_HOST", "0.0.0.0"), setting("APP_PORT", "8080")), Handler: a.routes(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, WriteTimeout: 15 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 16 * 1024}
serverErrors := make(chan error, 1)
go func() { log.Printf("server listening on %s", server.Addr); serverErrors <- server.ListenAndServe() }()
select {
case err := <-serverErrors:
if err != nil && err != http.ErrServerClosed {
log.Fatal(err)
}
case <-rootCtx.Done():
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
_ = server.Close()
}
}
}
func (a *app) routes() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", a.health)
mux.HandleFunc("GET /health/ready", a.health)
mux.HandleFunc("GET /metrics", a.metricsHandler)
mux.HandleFunc("POST /api/v1/users", a.users)
mux.HandleFunc("POST /api/v1/auth/sessions", a.login)
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", a.logout)
mux.HandleFunc("GET /api/v1/users/me", a.currentUser)
mux.HandleFunc("/api/v1/chats", a.chats)
mux.HandleFunc("/api/v1/chats/", a.chatResource)
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
a.error(w, 404, "not_found", "Объект не найден")
})
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-Request-Id", newID())
a.metrics.requests.Add(1)
if r.ContentLength > a.limits.maxBodyBytes {
a.metrics.status413.Add(1)
a.error(w, 413, "payload_too_large", "Размер запроса превышает лимит")
return
}
// Health and metrics remain observable while the business admission gate is full.
if !strings.HasPrefix(r.URL.Path, "/health/") && r.URL.Path != "/metrics" {
select {
case a.gate <- struct{}{}:
a.metrics.inFlight.Add(1)
defer func() { <-a.gate; a.metrics.inFlight.Add(-1) }()
default:
a.rateLimited(w)
return
}
}
defer func() {
if recover() != nil {
a.error(w, 500, "internal_error", "Внутренняя ошибка")
}
}()
ctx, cancel := context.WithTimeout(r.Context(), a.timeout)
defer cancel()
mux.ServeHTTP(w, r.WithContext(ctx))
})
}
func (a *app) error(w http.ResponseWriter, status int, code, message string) {
writeJSON(w, status, map[string]any{"error": map[string]string{"code": code, "message": message, "request_id": w.Header().Get("X-Request-Id")}})
}
func (a *app) unavailable(w http.ResponseWriter) {
a.metrics.status503.Add(1)
a.error(w, 503, "unavailable", "Хранилище временно недоступно")
}
func (a *app) unauthorized(w http.ResponseWriter, basic bool) {
scheme := `Bearer realm="messenger"`
if basic {
scheme = `Basic realm="messenger", charset="UTF-8"`
}
w.Header().Set("WWW-Authenticate", scheme)
a.error(w, 401, "unauthorized", "Нет действительной аутентификации")
}
func (a *app) rateLimited(w http.ResponseWriter) {
w.Header().Set("Retry-After", "1")
a.metrics.status429.Add(1)
a.error(w, 429, "rate_limited", "Слишком много запросов")
}
func (a *app) kdf(w http.ResponseWriter) bool {
select {
case a.kdfGate <- struct{}{}:
return true
default:
a.rateLimited(w)
return false
}
}
func (a *app) decode(w http.ResponseWriter, r *http.Request, target any) bool {
data, err := io.ReadAll(http.MaxBytesReader(w, r.Body, a.limits.maxBodyBytes))
if err != nil {
var large *http.MaxBytesError
if errors.As(err, &large) {
a.metrics.status413.Add(1)
a.error(w, 413, "payload_too_large", "Размер запроса превышает лимит")
} else {
a.error(w, 400, "invalid_request", "Неверный JSON")
}
return false
}
decoder := json.NewDecoder(bytes.NewReader(data))
decoder.DisallowUnknownFields()
var extra any
if !utf8.Valid(data) || decoder.Decode(target) != nil || decoder.Decode(&extra) != io.EOF {
a.error(w, 400, "invalid_request", "Неверный JSON")
return false
}
return true
}
func (a *app) health(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/health/ready" && a.store.db.PingContext(r.Context()) != nil {
a.unavailable(w)
return
}
writeJSON(w, 200, map[string]string{"status": "ok"})
}
func (a *app) metricsHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/plain; version=0.0.4")
_, _ = fmt.Fprint(w, a.metrics.snapshot())
_, _ = fmt.Fprintf(w, "messenger_profile_cache_hits_total %d\nmessenger_profile_cache_misses_total %d\nmessenger_profile_cache_failures_total %d\nmessenger_db_connections %d\n", a.cacheMetrics.hits.Load(), a.cacheMetrics.misses.Load(), a.cacheMetrics.failures.Load(), a.store.db.Stats().OpenConnections)
}
func (a *app) users(w http.ResponseWriter, r *http.Request) {
var input createUser
if !a.decode(w, r, &input) {
return
}
if !usernamePattern.MatchString(input.Username) || !validText(input.DisplayName, 100) || !validPassword(input.Password) {
a.error(w, 400, "invalid_request", "Неверные поля пользователя")
return
}
if !a.kdf(w) {
return
}
hash := hashPassword(input.Password)
<-a.kdfGate
user, err := scanUser(a.store.db.QueryRowContext(r.Context(), `INSERT INTO users(id,username,display_name,password_hash) VALUES($1,$2,$3,$4) RETURNING id,username,display_name,created_at`, newID(), input.Username, input.DisplayName, hash))
if err != nil {
var pg *pq.Error
if errors.As(err, &pg) && pg.Code == "23505" {
a.error(w, 409, "conflict", "Имя пользователя уже занято")
} else {
a.unavailable(w)
}
return
}
writeJSON(w, 201, user)
}
func (a *app) login(w http.ResponseWriter, r *http.Request) {
data, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1))
if err != nil || len(data) != 0 {
a.error(w, 400, "invalid_request", "Вход не принимает тело запроса")
return
}
username, password, ok := r.BasicAuth()
if !ok || !usernamePattern.MatchString(username) || !validPassword(password) {
a.unauthorized(w, true)
return
}
var user models.User
var hash string
err = a.store.db.QueryRowContext(r.Context(), `SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=$1`, username).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt, &hash)
missing := errors.Is(err, sql.ErrNoRows)
if err != nil && !missing {
a.unavailable(w)
return
}
if missing {
hash = a.dummyHash
}
if !a.kdf(w) {
return
}
valid := verifyPassword(hash, password)
<-a.kdfGate
if !valid || missing {
a.unauthorized(w, true)
return
}
data = make([]byte, 32)
if _, err = rand.Read(data); err != nil {
panic(err)
}
token := base64.RawURLEncoding.EncodeToString(data)
digest := sha256.Sum256([]byte(token))
var expires time.Time
err = a.store.db.QueryRowContext(r.Context(), `INSERT INTO sessions(token_hash,user_id,expires_at) VALUES($1,$2,clock_timestamp()+$3*interval '1 second') RETURNING expires_at`, digest[:], user.ID, int(a.ttl/time.Second)).Scan(&expires)
if err != nil {
a.unavailable(w)
return
}
user.CreatedAt = user.CreatedAt.UTC()
writeJSON(w, 201, map[string]any{"token": token, "token_type": "Bearer", "expires_at": expires.UTC(), "user": user})
}
func bearer(r *http.Request) string {
parts := strings.Fields(r.Header.Get("Authorization"))
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") || len(parts[1]) != 43 {
return ""
}
data, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil || len(data) != 32 {
return ""
}
return parts[1]
}
func (a *app) authenticate(w http.ResponseWriter, r *http.Request) (models.UUID, bool) {
token := bearer(r)
if token == "" {
a.unauthorized(w, false)
return "", false
}
digest := sha256.Sum256([]byte(token))
var user models.UUID
err := a.store.db.QueryRowContext(r.Context(), `SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp()`, digest[:]).Scan(&user)
if errors.Is(err, sql.ErrNoRows) {
a.unauthorized(w, false)
return "", false
}
if err != nil {
a.unavailable(w)
return "", false
}
return user, true
}
func (a *app) logout(w http.ResponseWriter, r *http.Request) {
token := bearer(r)
if token == "" {
a.unauthorized(w, false)
return
}
digest := sha256.Sum256([]byte(token))
var id models.UUID
err := a.store.db.QueryRowContext(r.Context(), `DELETE FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp() RETURNING user_id`, digest[:]).Scan(&id)
if errors.Is(err, sql.ErrNoRows) {
a.unauthorized(w, false)
return
}
if err != nil {
a.unavailable(w)
return
}
w.WriteHeader(204)
}
func (a *app) currentUser(w http.ResponseWriter, r *http.Request) {
id, ok := a.authenticate(w, r)
if !ok {
return
}
u, err := a.store.user(r.Context(), id)
if err != nil {
a.unavailable(w)
return
}
writeJSON(w, 200, u)
}
func (a *app) chats(w http.ResponseWriter, r *http.Request) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
if r.Method == http.MethodPost {
var input createChat
if !a.decode(w, r, &input) {
return
}
if !validText(input.Title, 100) || len(input.MemberIDs) < 1 || len(input.MemberIDs) > 100 {
a.error(w, 400, "invalid_request", "Неверные поля чата")
return
}
seen := map[models.UUID]bool{}
for i, id := range input.MemberIDs {
id = models.UUID(strings.ToLower(string(id)))
if !isUUID(string(id)) || seen[id] {
a.error(w, 400, "invalid_request", "Неверные участники")
return
}
seen[id] = true
input.MemberIDs[i] = id
}
if !seen[user] {
a.error(w, 400, "invalid_request", "Создатель должен быть участником")
return
}
chat, err := a.store.createChat(r.Context(), input.Title, input.MemberIDs)
if err != nil {
var pg *pq.Error
if errors.As(err, &pg) && pg.Code == "23503" {
a.error(w, 400, "invalid_request", "Неизвестный участник")
} else {
a.unavailable(w)
}
return
}
writeJSON(w, 201, chat)
return
}
if r.Method != http.MethodGet {
a.error(w, 404, "not_found", "Объект не найден")
return
}
resource := "chats:" + string(user)
p, limit, ok := a.position(w, r, resource)
if !ok {
return
}
items, err := a.store.chats(r.Context(), user, p, limit)
if err != nil {
a.unavailable(w)
return
}
var next any
if len(items) > limit {
items = items[:limit]
last := items[len(items)-1]
next = encodeCursor(cursor{resource, last.CreatedAt, last.ID})
}
writeJSON(w, 200, map[string]any{"items": items, "next_cursor": next})
}
func (a *app) chatResource(w http.ResponseWriter, r *http.Request) {
user, ok := a.authenticate(w, r)
if !ok {
return
}
parts := strings.Split(strings.TrimPrefix(r.URL.Path, "/api/v1/chats/"), "/")
if !isUUID(parts[0]) {
a.error(w, 400, "invalid_request", "Неверный UUID")
return
}
chatID := models.UUID(strings.ToLower(parts[0]))
chat, err := a.store.chat(r.Context(), chatID, user)
if errors.Is(err, sql.ErrNoRows) {
a.error(w, 404, "not_found", "Объект не найден")
return
}
if err != nil {
a.unavailable(w)
return
}
if len(parts) == 1 && r.Method == http.MethodGet {
writeJSON(w, 200, chat)
return
}
if len(parts) != 2 || parts[1] != "messages" {
a.error(w, 404, "not_found", "Объект не найден")
return
}
if r.Method == http.MethodPost {
var input createMessage
if !a.decode(w, r, &input) {
return
}
if !validText(input.Text, 4000) {
a.error(w, 400, "invalid_request", "Неверный текст")
return
}
m := models.Message{ID: models.UUID(newID()), ChatID: chatID, SenderID: user, Text: input.Text}
err = a.store.db.QueryRowContext(r.Context(), `INSERT INTO messages(id,chat_id,sender_id,text) VALUES($1,$2,$3,$4) RETURNING created_at`, m.ID, chatID, user, input.Text).Scan(&m.CreatedAt)
if err != nil {
a.unavailable(w)
return
}
m.CreatedAt = m.CreatedAt.UTC()
a.metrics.accepted.Add(1)
writeJSON(w, 201, m)
return
}
if r.Method != http.MethodGet {
a.error(w, 404, "not_found", "Объект не найден")
return
}
resource := "messages:" + string(chatID)
p, limit, ok := a.position(w, r, resource)
if !ok {
return
}
items, err := a.store.messages(r.Context(), chatID, p, limit)
if err != nil {
a.unavailable(w)
return
}
var next any
if len(items) > limit {
items = items[:limit]
last := items[len(items)-1]
next = encodeCursor(cursor{resource, last.CreatedAt, last.ID})
}
writeJSON(w, 200, map[string]any{"items": items, "next_cursor": next})
}
func (a *app) position(w http.ResponseWriter, r *http.Request, resource string) (cursor, int, bool) {
limit := 50
var err error
if value := r.URL.Query().Get("limit"); value != "" {
limit, err = strconv.Atoi(value)
}
p := cursor{Resource: resource, CreatedAt: time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC), ID: "00000000-0000-0000-0000-000000000000"}
if limit < 1 || limit > 100 || err != nil {
a.error(w, 400, "invalid_request", "Неверный limit")
return p, 0, false
}
if value := r.URL.Query().Get("cursor"); value != "" {
data, e := base64.RawURLEncoding.DecodeString(value)
if len(value) > 1024 || e != nil || json.Unmarshal(data, &p) != nil || p.Resource != resource || !isUUID(string(p.ID)) || p.CreatedAt.IsZero() {
a.error(w, 400, "invalid_request", "Неверный cursor")
return p, 0, false
}
}
return p, limit, true
}
func encodeCursor(p cursor) string {
data, _ := json.Marshal(p)
return base64.RawURLEncoding.EncodeToString(data)
}
func validText(value string, max int) bool {
return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= max
}
func isUUID(value string) bool { return uuidPattern.MatchString(value) }
func writeJSON(w http.ResponseWriter, status int, value any) {
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(value)
}
func newID() string {
data := make([]byte, 16)
if _, err := rand.Read(data); err != nil {
panic(err)
}
data[6] = (data[6] & 0x0f) | 0x40
data[8] = (data[8] & 0x3f) | 0x80
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", data[:4], data[4:6], data[6:8], data[8:10], data[10:])
}