Files
mtusi2026lab4/internal/handler/handler.go
T

663 lines
20 KiB
Go

package handler
import (
"context"
_ "embed"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"sync/atomic"
"time"
"unicode"
"unicode/utf8"
"github.com/google/uuid"
"messenger/internal/media"
"messenger/internal/model"
"messenger/internal/s3store"
"messenger/internal/store"
)
//go:embed openapi.json
var openAPISpec []byte
const swaggerUIHTML = `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>MTUCI Messenger API (Lab 4) - Swagger UI</title>
<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" />
<style>
body { margin: 0; background: #fafafa; }
.swagger-ui .topbar { display: none; }
</style>
</head>
<body>
<div id="swagger-ui"></div>
<script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
<script>
window.onload = function() {
SwaggerUIBundle({
url: "/openapi.json",
dom_id: '#swagger-ui',
deepLinking: true,
presets: [
SwaggerUIBundle.presets.apis,
SwaggerUIBundle.SwaggerUIStandalonePreset
],
layout: "BaseLayout"
});
};
</script>
</body>
</html>`
type APIHandler struct {
store store.Store
s3 *s3store.Client
sessionTTL int
idempotencyTTL int
maxUploadBytes int64
maxImagePixels int64
instanceID string
draining atomic.Bool
}
func NewAPIHandler(st store.Store, s3 *s3store.Client, sessionTTL, idempotencyTTL int, maxUploadBytes, maxImagePixels int64, instanceID string) *APIHandler {
if sessionTTL <= 0 {
sessionTTL = 3600
}
if idempotencyTTL <= 0 {
idempotencyTTL = 86400
}
if maxUploadBytes <= 0 {
maxUploadBytes = 10 * 1024 * 1024
}
if maxImagePixels <= 0 {
maxImagePixels = 40_000_000
}
return &APIHandler{
store: st,
s3: s3,
sessionTTL: sessionTTL,
idempotencyTTL: idempotencyTTL,
maxUploadBytes: maxUploadBytes,
maxImagePixels: maxImagePixels,
instanceID: instanceID,
}
}
func (h *APIHandler) SetDraining(v bool) {
h.draining.Store(v)
}
func (h *APIHandler) IsDraining() bool {
return h.draining.Load()
}
func decodeJSON(r *http.Request, dst interface{}) error {
if r.Body == nil {
return errors.New("request body is missing")
}
defer r.Body.Close()
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
if errors.Is(err, io.EOF) {
return errors.New("request body is empty")
}
var unmarshalTypeError *json.UnmarshalTypeError
if errors.As(err, &unmarshalTypeError) {
return fmt.Errorf("field '%s' has incorrect type (expected %s)", unmarshalTypeError.Field, unmarshalTypeError.Type)
}
return fmt.Errorf("malformed JSON or unexpected field: %v", err)
}
if dec.More() {
return errors.New("request body contains multiple JSON values")
}
return nil
}
func writeStoreError(w http.ResponseWriter, r *http.Request, err error) {
switch {
case errors.Is(err, store.ErrConflict):
WriteError(w, r, http.StatusConflict, "conflict", "resource conflict")
case errors.Is(err, store.ErrNotFound):
WriteError(w, r, http.StatusNotFound, "not_found", "resource not found or access denied")
case errors.Is(err, store.ErrUnauthorized):
WriteBearerUnauthorized(w, r, "unauthorized")
case errors.Is(err, store.ErrUnavailable):
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
case errors.Is(err, store.ErrBadRequest):
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
default:
WriteError(w, r, http.StatusInternalServerError, "internal_error", "internal server error")
}
}
func (h *APIHandler) HandleLiveness(w http.ResponseWriter, r *http.Request) {
WriteJSON(w, r, http.StatusOK, model.HealthResponse{Status: "ok"})
}
func (h *APIHandler) HandleReadiness(w http.ResponseWriter, r *http.Request) {
if h.IsDraining() {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "instance is draining")
return
}
if err := h.store.Ready(r.Context()); err != nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "database dependency is not ready")
return
}
if h.s3 == nil || h.s3.Ready(r.Context()) != nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage dependency is not ready")
return
}
WriteJSON(w, r, http.StatusOK, model.HealthResponse{Status: "ok"})
}
func (h *APIHandler) HandleRegisterUser(w http.ResponseWriter, r *http.Request) {
var req model.CreateUserRequest
if err := decodeJSON(r, &req); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
user, err := h.store.CreateUser(r.Context(), req)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, user)
}
func (h *APIHandler) HandleCreateSession(w http.ResponseWriter, r *http.Request) {
// Contract: POST /auth/sessions accepts ONLY Authorization: Basic <base64(username:password)>, without JSON body.
if r.Body != nil {
defer r.Body.Close()
var buf [1]byte
n, _ := r.Body.Read(buf[:])
if n > 0 {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "POST /api/v1/auth/sessions must not include a request body")
return
}
}
authHeader := strings.TrimSpace(r.Header.Get("Authorization"))
if authHeader == "" {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
parts := strings.SplitN(authHeader, " ", 2)
if len(parts) != 2 || !strings.EqualFold(parts[0], "Basic") {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
b64Payload := strings.TrimSpace(parts[1])
decoded, err := base64.StdEncoding.DecodeString(b64Payload)
if err != nil || !utf8.Valid(decoded) {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
credParts := strings.SplitN(string(decoded), ":", 2)
if len(credParts) != 2 {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
username := credParts[0]
password := credParts[1]
sess, err := h.store.AuthenticateAndCreateSession(r.Context(), username, password, h.sessionTTL)
if err != nil {
if errors.Is(err, store.ErrUnavailable) {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
return
}
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
WriteJSON(w, r, http.StatusCreated, sess)
}
func (h *APIHandler) HandleRevokeSession(w http.ResponseWriter, r *http.Request) {
rawToken := GetAuthToken(r.Context())
if rawToken == "" {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
if err := h.store.RevokeSession(r.Context(), rawToken); err != nil {
if errors.Is(err, store.ErrUnavailable) {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
return
}
WriteBearerUnauthorized(w, r, "session already revoked or expired")
return
}
reqID := GetRequestID(r.Context())
w.Header().Set("X-Request-Id", reqID)
w.WriteHeader(http.StatusNoContent)
}
func (h *APIHandler) HandleCurrentUser(w http.ResponseWriter, r *http.Request) {
user := GetAuthUser(r.Context())
if user == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
WriteJSON(w, r, http.StatusOK, user)
}
func (h *APIHandler) HandleCreateChat(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
var req model.CreateChatRequest
if err := decodeJSON(r, &req); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
chat, err := h.store.CreateChat(r.Context(), caller.ID, req)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, chat)
}
func (h *APIHandler) HandleListChats(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
limit := 50
limitStr := r.URL.Query().Get("limit")
if limitStr != "" {
l, err := strconv.Atoi(limitStr)
if err != nil || l < 1 || l > 100 {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "limit must be an integer between 1 and 100")
return
}
limit = l
}
cursor := r.URL.Query().Get("cursor")
page, err := h.store.ListChats(r.Context(), caller.ID, limit, cursor)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, page)
}
func (h *APIHandler) HandleGetChat(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
chat, err := h.store.GetChat(r.Context(), caller.ID, chatID)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, chat)
}
func (h *APIHandler) HandleCreateMessage(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
idemKey := r.Header.Get("Idempotency-Key")
if !store.IdempotencyKeyRegex.MatchString(idemKey) {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "Idempotency-Key header is required and must match ^[A-Za-z0-9._:-]{1,128}$")
return
}
var req model.CreateMessageRequest
if err := decodeJSON(r, &req); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
msg, err := h.store.CreateMessage(r.Context(), caller.ID, chatID, idemKey, h.idempotencyTTL, req)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, msg)
}
func (h *APIHandler) HandleListMessages(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
limit := 50
limitStr := r.URL.Query().Get("limit")
if limitStr != "" {
l, err := strconv.Atoi(limitStr)
if err != nil || l < 1 || l > 100 {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "limit must be an integer between 1 and 100")
return
}
limit = l
}
cursor := r.URL.Query().Get("cursor")
page, err := h.store.ListMessages(r.Context(), caller.ID, chatID, limit, cursor)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, page)
}
func (h *APIHandler) HandleInternalStats(w http.ResponseWriter, r *http.Request) {
if r.URL.Query().Get("reset") == "1" {
h.store.ResetStats()
}
if mode := r.URL.Query().Get("mode"); mode != "" {
h.store.SetCacheMode(mode)
}
WriteJSON(w, r, http.StatusOK, h.store.Stats(r.Context()))
}
func (h *APIHandler) HandleOpenAPISpec(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Request-Id", GetRequestID(r.Context()))
w.WriteHeader(http.StatusOK)
_, _ = w.Write(openAPISpec)
}
func (h *APIHandler) HandleSwaggerUI(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("X-Request-Id", GetRequestID(r.Context()))
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(swaggerUIHTML))
}
func (h *APIHandler) HandleNotFound(w http.ResponseWriter, r *http.Request) {
WriteError(w, r, http.StatusNotFound, "not_found", fmt.Sprintf("route %s %s not found", r.Method, r.URL.Path))
}
func validateFilename(name string) bool {
if strings.TrimSpace(name) == "" {
return false
}
n := utf8.RuneCountInString(name)
if n < 1 || n > 255 {
return false
}
for _, r := range name {
if r == '/' || r == '\\' || r == 0 || unicode.IsControl(r) {
return false
}
}
return true
}
func (h *APIHandler) HandleUploadAttachment(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
filename := r.URL.Query().Get("filename")
if !validateFilename(filename) {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid or missing filename")
return
}
contentTypeHeader := r.Header.Get("Content-Type")
if _, err := media.ParseAllowedContentType(contentTypeHeader); err != nil {
WriteError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Content-Type must be image/png or image/jpeg")
return
}
if r.ContentLength > h.maxUploadBytes {
WriteError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "upload exceeds maximum allowed byte size")
return
}
// Enforce chat membership BEFORE spooling bytes or touching S3
isMember, err := h.store.IsChatMember(r.Context(), caller.ID, chatID)
if err != nil {
writeStoreError(w, r, err)
return
}
if !isMember {
WriteError(w, r, http.StatusNotFound, "not_found", "resource not found or access denied")
return
}
if h.s3 == nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage dependency is unavailable")
return
}
r.Body = http.MaxBytesReader(w, r.Body, h.maxUploadBytes+1024)
img, err := media.ValidateAndSpoolImage(r.Body, contentTypeHeader, h.maxUploadBytes, h.maxImagePixels)
if err != nil {
switch {
case errors.Is(err, media.ErrPayloadTooLarge):
WriteError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "image exceeds byte or pixel limit")
case errors.Is(err, media.ErrUnsupportedMediaType):
WriteError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "payload is not a valid PNG or JPEG image matching Content-Type")
default:
WriteError(w, r, http.StatusBadRequest, "invalid_request", "failed to read upload stream")
}
return
}
defer img.Cleanup()
attID := uuid.New().String()
objectKey := fmt.Sprintf("attachments/%s/%s", chatID, attID)
if err := h.s3.PutObject(r.Context(), objectKey, img.File, img.SizeBytes, img.ContentType); err != nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage temporarily unavailable")
return
}
att, err := h.store.CreateAttachment(r.Context(), model.Attachment{
ID: attID,
ChatID: chatID,
OwnerID: caller.ID,
Filename: filename,
ContentType: img.ContentType,
SizeBytes: img.SizeBytes,
SHA256: img.SHA256,
ObjectKey: objectKey,
})
if err != nil {
// Immediate synchronous compensation: delete the unreferenced S3 object if DB commit failed.
compCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
_ = h.s3.RemoveObject(compCtx, objectKey)
cancel()
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, att)
}
func (h *APIHandler) HandleGetAttachment(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
attID := r.PathValue("attachment_id")
if _, err := uuid.Parse(attID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id UUID")
return
}
att, err := h.store.GetAttachment(r.Context(), caller.ID, attID)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, att)
}
func (h *APIHandler) HandleDownloadAttachmentContent(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
attID := r.PathValue("attachment_id")
if _, err := uuid.Parse(attID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id UUID")
return
}
variant := r.URL.Query().Get("variant")
if variant != "" && variant != "original" {
if variant == "thumbnail" || variant == "crop" || variant == "optimized" {
WriteError(w, r, http.StatusNotFound, "not_found", "requested variant does not exist")
return
}
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid variant query parameter")
return
}
att, err := h.store.GetAttachment(r.Context(), caller.ID, attID)
if err != nil {
writeStoreError(w, r, err)
return
}
if att.Status != "ready" {
WriteError(w, r, http.StatusConflict, "conflict", "attachment is not ready for download")
return
}
if h.s3 == nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage temporarily unavailable")
return
}
obj, objSize, err := h.s3.GetObject(r.Context(), att.ObjectKey)
if err != nil {
if errors.Is(err, s3store.ErrObjectNotFound) {
WriteError(w, r, http.StatusConflict, "conflict", "attachment binary object is unavailable")
return
}
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage temporarily unavailable")
return
}
defer obj.Close()
w.Header().Set("Content-Type", att.ContentType)
w.Header().Set("Content-Length", strconv.FormatInt(objSize, 10))
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("X-Request-Id", GetRequestID(r.Context()))
w.WriteHeader(http.StatusOK)
_, _ = io.Copy(w, obj)
}
func RegisterRoutes(st store.Store, s3 *s3store.Client, sessionTTL, idempotencyTTL int, maxUploadBytes, maxImagePixels int64, instanceID string) (http.Handler, *APIHandler) {
api := NewAPIHandler(st, s3, sessionTTL, idempotencyTTL, maxUploadBytes, maxImagePixels, instanceID)
mux := http.NewServeMux()
// Documentation & schema
mux.HandleFunc("GET /docs", api.HandleSwaggerUI)
mux.HandleFunc("GET /docs/", api.HandleSwaggerUI)
mux.HandleFunc("GET /openapi.json", api.HandleOpenAPISpec)
// Internal diagnostics for experiments
mux.HandleFunc("GET /internal/stats", api.HandleInternalStats)
mux.HandleFunc("POST /internal/stats", api.HandleInternalStats)
// Public routes
mux.HandleFunc("GET /health/live", api.HandleLiveness)
mux.HandleFunc("GET /health/ready", api.HandleReadiness)
mux.HandleFunc("POST /api/v1/users", api.HandleRegisterUser)
mux.HandleFunc("POST /api/v1/auth/sessions", api.HandleCreateSession)
// Protected Bearer routes
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", RequireBearerAuth(st, api.HandleRevokeSession))
mux.HandleFunc("GET /api/v1/users/me", RequireBearerAuth(st, api.HandleCurrentUser))
mux.HandleFunc("POST /api/v1/chats", RequireBearerAuth(st, api.HandleCreateChat))
mux.HandleFunc("GET /api/v1/chats", RequireBearerAuth(st, api.HandleListChats))
mux.HandleFunc("GET /api/v1/chats/{chat_id}", RequireBearerAuth(st, api.HandleGetChat))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", RequireBearerAuth(st, api.HandleCreateMessage))
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", RequireBearerAuth(st, api.HandleListMessages))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", RequireBearerAuth(st, api.HandleUploadAttachment))
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", RequireBearerAuth(st, api.HandleGetAttachment))
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", RequireBearerAuth(st, api.HandleDownloadAttachmentContent))
// Fallback 404 handler
mux.HandleFunc("/", api.HandleNotFound)
var handler http.Handler = mux
handler = LoggingMiddleware(instanceID, handler)
handler = RequestIDMiddleware(handler)
handler = InstanceIDMiddleware(instanceID, handler)
return handler, api
}