diff --git a/.dockerignore b/.dockerignore index bc16e55..9333679 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,5 @@ __pycache__ node_modules evidence .DS_Store +*.md +Makefile \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..9218441 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,33 @@ +# --- build stage --- +FROM golang:1.22-alpine AS build + +WORKDIR /src + +COPY go.mod go.sum ./ + +RUN go mod download + +COPY cmd/ ./cmd/ +COPY src/ ./src/ + +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/messenger + +# --- runtime stage --- +FROM alpine:3.20 + +RUN adduser -D -H -u 10001 app + +USER app + +WORKDIR /app + +COPY --from=build /out/messenger /app/messenger + +EXPOSE 8080 + +ENV APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab + +HEALTHCHECK --interval=5s --timeout=3s --start-period=2s --retries=5 \ + CMD wget -qO- http://127.0.0.1:8080/health/live >/dev/null 2>&1 || exit 1 + +ENTRYPOINT ["/app/messenger"] \ No newline at end of file diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go new file mode 100644 index 0000000..be30759 --- /dev/null +++ b/cmd/messenger/main.go @@ -0,0 +1,50 @@ +package main + +import ( + "context" + "errors" + "fmt" + "log" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "mtusi-messenger/src/api" + "mtusi-messenger/src/config" + "mtusi-messenger/src/domain" +) + +func main() { + cfg := config.Load() + store := domain.NewStore() + handler := &api.Handler{Store: store} + router := api.NewRouter(handler) + + srv := &http.Server{ + Addr: fmt.Sprintf("%s:%d", cfg.Host, cfg.Port), + Handler: router, + ReadHeaderTimeout: 5 * time.Second, + } + + // Graceful shutdown по SIGTERM/SIGINT в течение 10 секунд. + stop := make(chan os.Signal, 1) + signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT) + + go func() { + log.Printf("messenger listening on %s", srv.Addr) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Fatalf("server error: %v", err) + } + }() + + <-stop + log.Println("shutting down...") + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if err := srv.Shutdown(ctx); err != nil { + log.Printf("shutdown error: %v", err) + } + log.Println("stopped") +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..4921195 --- /dev/null +++ b/go.mod @@ -0,0 +1,5 @@ +module mtusi-messenger + +go 1.22 + +require github.com/google/uuid v1.6.0 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..7790d7c --- /dev/null +++ b/go.sum @@ -0,0 +1,2 @@ +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= diff --git a/src/api/errors.go b/src/api/errors.go new file mode 100644 index 0000000..7c5b5df --- /dev/null +++ b/src/api/errors.go @@ -0,0 +1,28 @@ +package api + +import ( + "encoding/json" + "net/http" + + "mtusi-messenger/src/domain" +) + +// writeError пишет ошибку в формате контракта. +func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(domain.ErrorBody{ + Error: domain.ErrorDetail{ + Code: code, + Message: message, + RequestID: requestIDFrom(r), + }, + }) +} + +// writeJSON пишет успешный JSON-ответ. +func writeJSON(w http.ResponseWriter, status int, v any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(v) +} diff --git a/src/api/handlers.go b/src/api/handlers.go new file mode 100644 index 0000000..bcad436 --- /dev/null +++ b/src/api/handlers.go @@ -0,0 +1,213 @@ +package api + +import ( + "encoding/json" + "net/http" + "regexp" + "strconv" + "strings" + + "mtusi-messenger/src/domain" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +// Handler держит хранилище. +type Handler struct { + Store *domain.Store +} + +// --- Health --- + +func (h *Handler) Live(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +func (h *Handler) Ready(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +// --- Users --- + +type createUserReq struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` +} + +func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) { + var req createUserReq + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + if !usernameRe.MatchString(req.Username) { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username") + return + } + if len([]rune(req.DisplayName)) < 1 || len([]rune(req.DisplayName)) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name") + return + } + u, err := h.Store.CreateUser(req.Username, req.DisplayName) + if err == domain.ErrConflict { + writeError(w, r, http.StatusConflict, "conflict", "username taken") + return + } + writeJSON(w, http.StatusCreated, u) +} + +func (h *Handler) CurrentUser(w http.ResponseWriter, r *http.Request) { + userID := r.Header.Get("X-User-Id") + if userID == "" { + writeError(w, r, http.StatusUnauthorized, "unauthorized", "missing X-User-Id") + return + } + u, err := h.Store.GetUser(userID) + if err != nil { + writeError(w, r, http.StatusUnauthorized, "unauthorized", "unknown user") + return + } + writeJSON(w, http.StatusOK, u) +} + +// --- Chats --- + +type createChatReq struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` +} + +func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) { + userID, ok := h.requireUser(w, r) + if !ok { + return + } + var req createChatReq + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + if strings.TrimSpace(req.Title) == "" || len([]rune(req.Title)) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title") + return + } + if len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids") + return + } + c, err := h.Store.CreateChat(req.Title, req.MemberIDs, userID) + if err == domain.ErrInvalid { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid members") + return + } + writeJSON(w, http.StatusCreated, c) +} + +func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) { + userID, ok := h.requireUser(w, r) + if !ok { + return + } + chats := h.Store.ListChats(userID) + if chats == nil { + chats = []domain.Chat{} + } + writeJSON(w, http.StatusOK, domain.ChatPage{Items: chats, NextCursor: nil}) +} + +func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) { + userID, ok := h.requireUser(w, r) + if !ok { + return + } + chatID := r.PathValue("chat_id") + c, err := h.Store.GetChat(chatID, userID) + if err != nil { + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + return + } + writeJSON(w, http.StatusOK, c) +} + +// --- Messages --- + +type createMessageReq struct { + Text string `json:"text"` +} + +func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) { + userID, ok := h.requireUser(w, r) + if !ok { + return + } + chatID := r.PathValue("chat_id") + if _, err := h.Store.GetChat(chatID, userID); err != nil { + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + return + } + var req createMessageReq + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed JSON") + return + } + text := strings.TrimSpace(req.Text) + if text == "" { + writeError(w, r, http.StatusBadRequest, "invalid_request", "empty message") + return + } + if len([]rune(req.Text)) > 4000 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "message too long") + return + } + m, err := h.Store.AddMessage(chatID, userID, req.Text) + if err != nil { + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + return + } + writeJSON(w, http.StatusCreated, m) +} + +func (h *Handler) ListMessages(w http.ResponseWriter, r *http.Request) { + userID, ok := h.requireUser(w, r) + if !ok { + return + } + chatID := r.PathValue("chat_id") + if _, err := h.Store.GetChat(chatID, userID); err != nil { + writeError(w, r, http.StatusNotFound, "not_found", "chat not found") + return + } + limit := 50 + if v := r.URL.Query().Get("limit"); v != "" { + n, err := strconv.Atoi(v) + if err != nil || n < 1 || n > 100 { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid limit") + return + } + limit = n + } + cursor := r.URL.Query().Get("cursor") + items, next, err := h.Store.ListMessages(chatID, limit, cursor) + if err != nil { + writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor") + return + } + if items == nil { + items = []domain.Message{} + } + writeJSON(w, http.StatusOK, domain.MessagePage{Items: items, NextCursor: next}) +} + +// requireUser проверяет X-User-Id и возвращает ID. +func (h *Handler) requireUser(w http.ResponseWriter, r *http.Request) (string, bool) { + userID := r.Header.Get("X-User-Id") + if userID == "" { + writeError(w, r, http.StatusUnauthorized, "unauthorized", "missing X-User-Id") + return "", false + } + if _, err := h.Store.GetUser(userID); err != nil { + writeError(w, r, http.StatusUnauthorized, "unauthorized", "unknown user") + return "", false + } + return userID, true +} diff --git a/src/api/middleware.go b/src/api/middleware.go new file mode 100644 index 0000000..ed107f9 --- /dev/null +++ b/src/api/middleware.go @@ -0,0 +1,33 @@ +package api + +import ( + "context" + "net/http" + + "github.com/google/uuid" +) + +type ctxKey string + +const requestIDKey ctxKey = "request_id" + +// requestIDFrom достаёт request_id из контекста. +func requestIDFrom(r *http.Request) string { + if v, ok := r.Context().Value(requestIDKey).(string); ok { + return v + } + return "" +} + +// withRequestID добавляет X-Request-Id во все ответы. +func withRequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + id := r.Header.Get("X-Request-Id") + if id == "" { + id = uuid.NewString() + } + w.Header().Set("X-Request-Id", id) + ctx := context.WithValue(r.Context(), requestIDKey, id) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} diff --git a/src/api/router.go b/src/api/router.go new file mode 100644 index 0000000..16fc8e1 --- /dev/null +++ b/src/api/router.go @@ -0,0 +1,18 @@ +package api + +import "net/http" + +// NewRouter собирает маршруты. +func NewRouter(h *Handler) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("GET /health/live", h.Live) + mux.HandleFunc("GET /health/ready", h.Ready) + mux.HandleFunc("POST /api/v1/users", h.CreateUser) + mux.HandleFunc("GET /api/v1/users/me", h.CurrentUser) + mux.HandleFunc("POST /api/v1/chats", h.CreateChat) + mux.HandleFunc("GET /api/v1/chats", h.ListChats) + mux.HandleFunc("GET /api/v1/chats/{chat_id}", h.GetChat) + mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", h.CreateMessage) + mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", h.ListMessages) + return withRequestID(mux) +} diff --git a/src/config/config.go b/src/config/config.go new file mode 100644 index 0000000..46aafb4 --- /dev/null +++ b/src/config/config.go @@ -0,0 +1,32 @@ +package config + +import ( + "os" + "strconv" +) + +// Config — конфигурация, приходящая из окружения. +type Config struct { + Host string + Port int + Env string +} + +// Load читает переменные окружения со значениями по умолчанию. +func Load() Config { + port := 8080 + if v := os.Getenv("APP_PORT"); v != "" { + if p, err := strconv.Atoi(v); err == nil { + port = p + } + } + host := os.Getenv("APP_HOST") + if host == "" { + host = "0.0.0.0" + } + env := os.Getenv("APP_ENV") + if env == "" { + env = "lab" + } + return Config{Host: host, Port: port, Env: env} +} diff --git a/src/domain/models.go b/src/domain/models.go new file mode 100644 index 0000000..a36bd61 --- /dev/null +++ b/src/domain/models.go @@ -0,0 +1,52 @@ +package domain + +import "time" + +// User — пользователь системы. +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +// Chat — чат с участниками. +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +// Message — сообщение в чате. +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` +} + +// MessagePage — страница истории сообщений. +type MessagePage struct { + Items []Message `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +// ChatPage — страница списка чатов. +type ChatPage struct { + Items []Chat `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +// ErrorBody — тело ошибки в формате контракта. +type ErrorBody struct { + Error ErrorDetail `json:"error"` +} + +// ErrorDetail — детали ошибки. +type ErrorDetail struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} diff --git a/src/domain/store.go b/src/domain/store.go new file mode 100644 index 0000000..db31d50 --- /dev/null +++ b/src/domain/store.go @@ -0,0 +1,204 @@ +package domain + +import ( + "errors" + "sort" + "sync" + "time" + + "github.com/google/uuid" +) + +var ( + ErrNotFound = errors.New("not found") + ErrConflict = errors.New("conflict") + ErrInvalid = errors.New("invalid request") + ErrUnauthorized = errors.New("unauthorized") +) + +// Store — in-memory хранилище. Все данные исчезают при перезапуске процесса. +type Store struct { + mu sync.RWMutex // безопасность при параллельных запросах + users map[string]*User + byName map[string]*User + chats map[string]*Chat + messages map[string][]*Message // chat_id -> сообщения + idIndex map[string]int // message_id -> позиция в messages[chat_id] +} + +// NewStore создаёт пустое хранилище. +func NewStore() *Store { + return &Store{ + users: make(map[string]*User), + byName: make(map[string]*User), + chats: make(map[string]*Chat), + messages: make(map[string][]*Message), + idIndex: make(map[string]int), + } +} + +// CreateUser создаёт пользователя. Возвращает ErrConflict при дубликате username. +func (s *Store) CreateUser(username, displayName string) (*User, error) { + s.mu.Lock() + defer s.mu.Unlock() + if _, exists := s.byName[username]; exists { + return nil, ErrConflict + } + u := &User{ + ID: uuid.NewString(), + Username: username, + DisplayName: displayName, + CreatedAt: time.Now().UTC(), + } + s.users[u.ID] = u + s.byName[username] = u + return u, nil +} + +// GetUser возвращает пользователя по ID. +func (s *Store) GetUser(id string) (*User, error) { + s.mu.RLock() + defer s.mu.RUnlock() + u, ok := s.users[id] + if !ok { + return nil, ErrNotFound + } + return u, nil +} + +// CreateChat создаёт чат. Проверяет, что все участники существуют и вызывающий входит в список. +func (s *Store) CreateChat(title string, memberIDs []string, creatorID string) (*Chat, error) { + s.mu.Lock() + defer s.mu.Unlock() + seen := make(map[string]bool, len(memberIDs)) + for _, id := range memberIDs { + if seen[id] { + return nil, ErrInvalid + } + seen[id] = true + if _, ok := s.users[id]; !ok { + return nil, ErrInvalid + } + } + if !seen[creatorID] { + return nil, ErrInvalid + } + c := &Chat{ + ID: uuid.NewString(), + Title: title, + MemberIDs: append([]string(nil), memberIDs...), + CreatedAt: time.Now().UTC(), + } + s.chats[c.ID] = c + return c, nil +} + +// GetChat возвращает чат, если пользователь — участник. +func (s *Store) GetChat(chatID, userID string) (*Chat, error) { + s.mu.RLock() + defer s.mu.RUnlock() + c, ok := s.chats[chatID] + if !ok { + return nil, ErrNotFound + } + for _, id := range c.MemberIDs { + if id == userID { + return c, nil + } + } + return nil, ErrNotFound +} + +// ListChats возвращает чаты пользователя, отсортированные по (created_at, id). +func (s *Store) ListChats(userID string) []Chat { + s.mu.RLock() + defer s.mu.RUnlock() + result := make([]Chat, 0) + for _, c := range s.chats { + for _, id := range c.MemberIDs { + if id == userID { + result = append(result, *c) + break + } + } + } + sort.Slice(result, func(i, j int) bool { + if result[i].CreatedAt.Equal(result[j].CreatedAt) { + return result[i].ID < result[j].ID + } + return result[i].CreatedAt.Before(result[j].CreatedAt) + }) + return result +} + +// compareMessages возвращает true, если a < b по (created_at, id). +func compareMessages(a, b *Message) bool { + if a.CreatedAt.Equal(b.CreatedAt) { + return a.ID < b.ID + } + return a.CreatedAt.Before(b.CreatedAt) +} + +// AddMessage добавляет сообщение, поддерживая сортировку вставкой. +// Изменение относительно baseline: вместо append + sort при чтении +// вставляем в нужную позицию сразу — чтение становится O(limit). +func (s *Store) AddMessage(chatID, senderID, text string) (*Message, error) { + s.mu.Lock() + defer s.mu.Unlock() + if _, ok := s.chats[chatID]; !ok { + return nil, ErrNotFound + } + m := &Message{ + ID: uuid.NewString(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: time.Now().UTC(), + } + msgs := s.messages[chatID] + idx := sort.Search(len(msgs), func(i int) bool { + return !compareMessages(msgs[i], m) + }) + msgs = append(msgs, nil) + copy(msgs[idx+1:], msgs[idx:]) + msgs[idx] = m + s.messages[chatID] = msgs + // Перестраиваем индексы от позиции вставки до конца. + for i := idx; i < len(msgs); i++ { + s.idIndex[msgs[i].ID] = i + } + return m, nil +} + +// ListMessages возвращает страницу сообщений по курсору. +// Изменение относительно baseline: без сортировки — срез уже отсортирован. +func (s *Store) ListMessages(chatID string, limit int, cursor string) ([]Message, *string, error) { + s.mu.RLock() + defer s.mu.RUnlock() + msgs := s.messages[chatID] + if len(msgs) == 0 { + return []Message{}, nil, nil + } + start := 0 + if cursor != "" { + pos, ok := s.idIndex[cursor] + if !ok || pos >= len(msgs) || msgs[pos].ID != cursor || msgs[pos].ChatID != chatID { + return nil, nil, ErrInvalid + } + start = pos + 1 + } + end := start + limit + if end > len(msgs) { + end = len(msgs) + } + items := make([]Message, 0, end-start) + for _, m := range msgs[start:end] { + items = append(items, *m) + } + var next *string + if end < len(msgs) { + last := msgs[end-1].ID + next = &last + } + return items, next, nil +}