Files
mtusi2026lab2/internal/httpapi/server.go
T
Quzzqq cbb92b7aef
Application / application (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
2 lab
2026-10-23 16:31:42 +03:00

225 lines
6.7 KiB
Go

package httpapi
import (
"context"
"encoding/base64"
"errors"
"log/slog"
"net/http"
"runtime/debug"
"strconv"
"strings"
"sync/atomic"
"time"
"mtusi.local/messenger/internal/authpw"
"mtusi.local/messenger/internal/model"
"mtusi.local/messenger/internal/pgstore"
"mtusi.local/messenger/internal/sessions"
)
type API struct {
db *pgstore.Store
session *sessions.Store
log *slog.Logger
dummy string
draining atomic.Bool
}
func New(db *pgstore.Store, session *sessions.Store, logger *slog.Logger, dummyHash string) *API {
if logger == nil {
logger = slog.Default()
}
return &API{db: db, session: session, log: logger, dummy: dummyHash}
}
func (a *API) StartDraining() {
a.draining.Store(true)
}
func (a *API) Handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", a.live)
mux.HandleFunc("GET /health/ready", a.ready)
mux.HandleFunc("POST /api/v1/users", a.createUser)
mux.HandleFunc("GET /api/v1/users/me", a.currentUser)
mux.HandleFunc("POST /api/v1/auth/sessions", a.createSession)
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", a.revokeSession)
mux.HandleFunc("POST /api/v1/chats", a.createChat)
mux.HandleFunc("GET /api/v1/chats", a.listChats)
mux.HandleFunc("GET /api/v1/chats/{chat_id}", a.getChat)
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", a.createMessage)
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", a.listMessages)
mux.HandleFunc("/", a.notFound)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
started := time.Now()
id := newRequestID()
ctx, cancel := context.WithTimeout(r.Context(), 4*time.Second)
defer cancel()
ctx = context.WithValue(ctx, requestIDKey{}, id)
r = r.WithContext(ctx)
sw := &statusWriter{ResponseWriter: w, status: http.StatusOK}
sw.Header().Set("X-Request-Id", id)
defer func() {
if rec := recover(); rec != nil {
a.log.Error("panic", "request_id", id, "method", r.Method, "path", r.URL.Path)
a.log.Error("panic_stack", "request_id", id, "stack", string(debug.Stack()))
if !sw.wrote {
writeError(sw, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", id)
}
}
a.log.Info("request",
"request_id", id,
"method", r.Method,
"path", r.URL.Path,
"status", sw.status,
"duration_ms", float64(time.Since(started).Microseconds())/1000,
)
}()
if a.draining.Load() && r.URL.Path != "/health/live" {
writeError(sw, http.StatusServiceUnavailable, "unavailable", "Сервер завершает работу", id)
return
}
mux.ServeHTTP(sw, r)
})
}
func (a *API) live(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (a *API) ready(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
defer cancel()
if err := a.db.Ping(ctx); err != nil || a.session.Ping(ctx) != nil {
writeError(w, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", requestID(r))
return
}
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (a *API) notFound(w http.ResponseWriter, r *http.Request) {
writeError(w, http.StatusNotFound, "not_found", "Объект не найден", requestID(r))
}
func (a *API) requireUser(w http.ResponseWriter, r *http.Request) (model.User, bool) {
token, ok := bearerToken(r)
if !ok {
writeUnauthorized(w, r, false)
return model.User{}, false
}
userID, err := a.session.Lookup(r.Context(), token)
if errors.Is(err, model.ErrUnavailable) {
writeError(w, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", requestID(r))
return model.User{}, false
}
if err != nil {
writeUnauthorized(w, r, false)
return model.User{}, false
}
user, err := a.db.UserByID(r.Context(), userID)
if errors.Is(err, model.ErrUnavailable) {
writeError(w, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", requestID(r))
return model.User{}, false
}
if err != nil {
writeUnauthorized(w, r, false)
return model.User{}, false
}
return user, true
}
func bearerToken(r *http.Request) (string, bool) {
scheme, param, ok := splitAuth(r.Header.Get("Authorization"))
if !ok || !strings.EqualFold(scheme, "Bearer") || len(param) < 32 || strings.ContainsAny(param, " \t") {
return "", false
}
return param, true
}
func basicCredentials(r *http.Request) (string, string, bool) {
scheme, param, ok := splitAuth(r.Header.Get("Authorization"))
if !ok || !strings.EqualFold(scheme, "Basic") {
return "", "", false
}
raw, err := base64.StdEncoding.DecodeString(param)
if err != nil {
return "", "", false
}
username, password, ok := strings.Cut(string(raw), ":")
if !ok {
return "", "", false
}
return username, password, true
}
func splitAuth(header string) (string, string, bool) {
scheme, param, ok := strings.Cut(strings.TrimSpace(header), " ")
if !ok || scheme == "" || strings.TrimSpace(param) == "" {
return "", "", false
}
return scheme, strings.TrimSpace(param), true
}
func parseLimit(r *http.Request) (int, error) {
values, ok := r.URL.Query()["limit"]
if !ok {
return 50, nil
}
if len(values) != 1 {
return 0, errBadQuery
}
n, err := strconv.Atoi(values[0])
if err != nil || n < 1 || n > 100 {
return 0, errBadQuery
}
return n, nil
}
func parseCursor(r *http.Request) (*model.Cursor, error) {
values, ok := r.URL.Query()["cursor"]
if !ok {
return nil, nil
}
if len(values) != 1 || values[0] == "" {
return nil, errBadQuery
}
cursor, err := model.DecodeCursor(values[0])
if err != nil {
return nil, errBadQuery
}
return &cursor, nil
}
func writeStoreError(w http.ResponseWriter, r *http.Request, err error, invalidMessage string) {
switch {
case errors.Is(err, model.ErrConflict):
writeError(w, http.StatusConflict, "conflict", "Имя пользователя уже занято", requestID(r))
case errors.Is(err, model.ErrNotFound):
writeError(w, http.StatusNotFound, "not_found", "Объект не найден", requestID(r))
case errors.Is(err, model.ErrUnavailable):
writeError(w, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", requestID(r))
default:
writeError(w, http.StatusBadRequest, "invalid_request", invalidMessage, requestID(r))
}
}
func (a *API) checkPassword(password, encoded string) bool {
if encoded == "" {
encoded = a.dummy
}
return authpw.Verify(password, encoded)
}
type requestIDKey struct{}
func requestID(r *http.Request) string {
id, _ := r.Context().Value(requestIDKey{}).(string)
if id == "" {
id = newRequestID()
}
return id
}
var errBadQuery = errors.New("bad query")