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")