Перенести приложение из lab2, добавить идемпотентность, X-Instance-Id и отдельные миграции

This commit is contained in:
gera
2026-10-23 01:00:01 +03:00
parent 0ab3a341aa
commit 5f509b2c70
12 changed files with 1624 additions and 0 deletions
+19
View File
@@ -0,0 +1,19 @@
FROM golang:1.26-alpine@sha256:c95332c2af86b6d89b91bd0500f4b9529ccbd090a0d1855c6d1ceaa142ae8615 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY *.go ./
COPY migrations ./migrations
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger .
FROM alpine:3.21@sha256:ce64758a109eb420d874a118f87920e625e12d3634e03b4a5573fd9f6e5d3507
RUN adduser -D -u 10001 app
WORKDIR /app
COPY --from=build /out/messenger /app/messenger
USER 10001
EXPOSE 8080
ENV APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=3 \
CMD wget -qO- http://127.0.0.1:8080/health/ready >/dev/null || exit 1
ENTRYPOINT ["/app/messenger"]
+131
View File
@@ -0,0 +1,131 @@
package main
import (
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"strconv"
"strings"
"unicode/utf8"
"golang.org/x/crypto/argon2"
)
const (
argonTime = 2
argonMemory = 19456
argonThreads = 1
argonKeyLen = 32
argonSaltLen = 16
)
func hashPassword(password string) (string, error) {
salt := make([]byte, argonSaltLen)
if _, err := rand.Read(salt); err != nil {
return "", err
}
hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
b64Salt := base64.RawStdEncoding.EncodeToString(salt)
b64Hash := base64.RawStdEncoding.EncodeToString(hash)
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, argonMemory, argonTime, argonThreads, b64Salt, b64Hash), nil
}
func checkPassword(encoded, password string) (bool, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, errors.New("bad hash")
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
return false, err
}
var memory, timeCost, threads int
for _, p := range strings.Split(parts[3], ",") {
kv := strings.SplitN(p, "=", 2)
if len(kv) != 2 {
return false, errors.New("bad params")
}
n, err := strconv.Atoi(kv[1])
if err != nil {
return false, err
}
switch kv[0] {
case "m":
memory = n
case "t":
timeCost = n
case "p":
threads = n
}
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, err
}
want, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, err
}
got := argon2.IDKey([]byte(password), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want)))
return subtle.ConstantTimeCompare(got, want) == 1, nil
}
func newToken() (string, []byte, string, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
return "", nil, "", err
}
token := base64.RawURLEncoding.EncodeToString(raw)
sum := sha256.Sum256([]byte(token))
hash := make([]byte, len(sum))
copy(hash, sum[:])
return token, hash, hex.EncodeToString(hash), nil
}
func tokenHash(token string) ([]byte, string) {
sum := sha256.Sum256([]byte(token))
hash := make([]byte, len(sum))
copy(hash, sum[:])
return hash, hex.EncodeToString(hash)
}
func parseBasic(header string) (username, password string, ok bool) {
const prefix = "Basic "
if !strings.HasPrefix(header, prefix) {
return "", "", false
}
decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):]))
if err != nil {
return "", "", false
}
s := string(decoded)
i := strings.IndexByte(s, ':')
if i < 0 {
return "", "", false
}
username = s[:i]
password = s[i+1:]
return username, password, true
}
func parseBearer(header string) (string, bool) {
const prefix = "Bearer "
if !strings.HasPrefix(header, prefix) {
return "", false
}
tok := strings.TrimSpace(header[len(prefix):])
if tok == "" {
return "", false
}
return tok, true
}
func validPassword(p string) bool {
n := utf8.RuneCountInString(p)
return n >= 12 && n <= 128
}
+104
View File
@@ -0,0 +1,104 @@
package main
import (
"context"
"encoding/json"
"log/slog"
"time"
"github.com/redis/go-redis/v9"
)
type cachedSession struct {
UserID string `json:"user_id"`
ExpiresAt time.Time `json:"expires_at"`
}
type Cache struct {
rdb *redis.Client
log *slog.Logger
}
func openCache(log *slog.Logger) *Cache {
url, err := readSecret("CACHE_URL", "CACHE_URL_FILE")
if err != nil {
log.Warn("cache disabled", "err", err.Error())
return &Cache{log: log}
}
opt, err := redis.ParseURL(url)
if err != nil {
log.Warn("cache parse failed", "err", err.Error())
return &Cache{log: log}
}
opt.DialTimeout = 200 * time.Millisecond
opt.ReadTimeout = 200 * time.Millisecond
opt.WriteTimeout = 200 * time.Millisecond
opt.PoolTimeout = 200 * time.Millisecond
rdb := redis.NewClient(opt)
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()
if err := rdb.Ping(ctx).Err(); err != nil {
log.Warn("cache ping failed, will bypass", "err", err.Error())
}
return &Cache{rdb: rdb, log: log}
}
func (c *Cache) Close() {
if c.rdb != nil {
_ = c.rdb.Close()
}
}
func sessKey(hashHex string) string {
return "sess:" + hashHex
}
func (c *Cache) GetSession(ctx context.Context, hashHex string) (*cachedSession, bool) {
if c.rdb == nil {
return nil, false
}
ctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancel()
val, err := c.rdb.Get(ctx, sessKey(hashHex)).Result()
if err != nil {
return nil, false
}
var s cachedSession
if err := json.Unmarshal([]byte(val), &s); err != nil {
return nil, false
}
if time.Now().UTC().After(s.ExpiresAt) {
return nil, false
}
return &s, true
}
func (c *Cache) SetSession(ctx context.Context, hashHex string, userID string, expiresAt time.Time) {
if c.rdb == nil {
return
}
ttl := time.Until(expiresAt)
if ttl <= 0 {
return
}
body, err := json.Marshal(cachedSession{UserID: userID, ExpiresAt: expiresAt.UTC()})
if err != nil {
return
}
ctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancel()
if err := c.rdb.Set(ctx, sessKey(hashHex), body, ttl).Err(); err != nil {
c.log.Warn("cache set failed", "err", err.Error())
}
}
func (c *Cache) DelSession(ctx context.Context, hashHex string) {
if c.rdb == nil {
return
}
ctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancel()
if err := c.rdb.Del(ctx, sessKey(hashHex)).Err(); err != nil {
c.log.Warn("cache del failed", "err", err.Error())
}
}
+57
View File
@@ -0,0 +1,57 @@
package main
import (
"context"
"fmt"
"os"
"strings"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
func readSecret(envKey, fileKey string) (string, error) {
if v := os.Getenv(envKey); v != "" {
return strings.TrimSpace(v), nil
}
path := os.Getenv(fileKey)
if path == "" {
return "", fmt.Errorf("%s or %s required", envKey, fileKey)
}
b, err := os.ReadFile(path)
if err != nil {
return "", err
}
return strings.TrimSpace(string(b)), nil
}
func openDB(ctx context.Context) (*pgxpool.Pool, error) {
dsn, err := readSecret("DATABASE_URL", "DATABASE_URL_FILE")
if err != nil {
return nil, err
}
cfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, err
}
cfg.MaxConns = 10
cfg.MinConns = 2
cfg.MaxConnLifetime = 5 * time.Minute
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, err
}
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, err
}
return pool, nil
}
func dbCtx(parent context.Context) (context.Context, context.CancelFunc) {
return context.WithTimeout(parent, 3*time.Second)
}
+20
View File
@@ -0,0 +1,20 @@
module mtusi-messenger
go 1.26.0
require (
github.com/jackc/pgx/v5 v5.11.0
github.com/redis/go-redis/v9 v9.23.0
golang.org/x/crypto v0.58.0
)
require (
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
go.uber.org/atomic v1.12.0 // indirect
golang.org/x/sync v0.24.0 // indirect
golang.org/x/sys v0.49.0 // indirect
golang.org/x/text v0.43.0 // indirect
)
+41
View File
@@ -0,0 +1,41 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+998
View File
@@ -0,0 +1,998 @@
package main
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"regexp"
"strconv"
"strings"
"sync/atomic"
"time"
"unicode/utf8"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
var instanceID = func() string {
h, err := os.Hostname()
if err != nil || h == "" {
return newUUID()
}
return h
}()
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type apiError struct {
Code string `json:"code"`
Message string `json:"message"`
ReqID string `json:"request_id"`
}
type errorBody struct {
Error apiError `json:"error"`
}
type App struct {
db *pgxpool.Pool
cache *Cache
log *slog.Logger
ready atomic.Bool
sessionTTL time.Duration
idempotencyTTL time.Duration
}
func NewApp(db *pgxpool.Pool, cache *Cache, log *slog.Logger, sessionTTL, idempotencyTTL time.Duration) *App {
a := &App{db: db, cache: cache, log: log, sessionTTL: sessionTTL, idempotencyTTL: idempotencyTTL}
a.ready.Store(true)
return a
}
func (a *App) SetReady(v bool) {
a.ready.Store(v)
}
func newUUID() string {
var b [16]byte
_, _ = rand.Read(b[:])
b[6] = (b[6] & 0x0f) | 0x40
b[8] = (b[8] & 0x3f) | 0x80
return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16])
}
func nowUTC() time.Time {
return time.Now().UTC().Truncate(time.Microsecond)
}
func formatTime(t time.Time) string {
return t.UTC().Format("2006-01-02T15:04:05.000000Z")
}
func parseTime(s string) (time.Time, error) {
return time.Parse("2006-01-02T15:04:05.000000Z", s)
}
type statusWriter struct {
http.ResponseWriter
status int
}
func (w *statusWriter) WriteHeader(code int) {
w.status = code
w.ResponseWriter.WriteHeader(code)
}
type ctxKey int
const reqIDKey ctxKey = 1
func (a *App) Middleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
reqID := newUUID()
w.Header().Set("X-Request-Id", reqID)
w.Header().Set("X-Instance-Id", instanceID)
sw := &statusWriter{ResponseWriter: w, status: 200}
defer func() {
if rec := recover(); rec != nil {
a.writeErr(sw, reqID, 500, "internal_error", "internal error")
a.log.Error("panic", "request_id", reqID, "err", fmt.Sprint(rec))
}
a.log.Info("request",
"method", r.Method,
"path", r.URL.Path,
"status", sw.status,
"duration_ms", time.Since(start).Milliseconds(),
"request_id", reqID,
)
}()
next.ServeHTTP(sw, r.WithContext(context.WithValue(r.Context(), reqIDKey, reqID)))
})
}
func reqIDFrom(r *http.Request) string {
if v, ok := r.Context().Value(reqIDKey).(string); ok {
return v
}
return ""
}
func (a *App) writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
enc := json.NewEncoder(w)
enc.SetEscapeHTML(false)
_ = enc.Encode(v)
}
func (a *App) writeErr(w http.ResponseWriter, reqID string, status int, code, msg string) {
a.writeJSON(w, status, errorBody{Error: apiError{Code: code, Message: msg, ReqID: reqID}})
}
func (a *App) writeUnauthorized(w http.ResponseWriter, r *http.Request, realm string) {
reqID := reqIDFrom(r)
if realm == "Basic" {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
} else {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
}
a.writeErr(w, reqID, 401, "unauthorized", "unauthorized")
}
func (a *App) Routes() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", a.handleLive)
mux.HandleFunc("GET /health/ready", a.handleReady)
mux.HandleFunc("POST /api/v1/users", a.handleCreateUser)
mux.HandleFunc("GET /api/v1/users/me", a.handleMe)
mux.HandleFunc("POST /api/v1/chats", a.handleCreateChat)
mux.HandleFunc("GET /api/v1/chats", a.handleListChats)
mux.HandleFunc("GET /api/v1/chats/{chat_id}", a.handleGetChat)
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", a.handleCreateMessage)
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", a.handleListMessages)
mux.HandleFunc("POST /api/v1/auth/sessions", a.handleCreateSession)
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", a.handleRevokeSession)
return a.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_, pattern := mux.Handler(r)
if pattern == "" {
a.writeErr(w, reqIDFrom(r), 404, "not_found", "not found")
return
}
mux.ServeHTTP(w, r)
}))
}
func (a *App) handleLive(w http.ResponseWriter, r *http.Request) {
a.writeJSON(w, 200, map[string]string{"status": "ok"})
}
func (a *App) handleReady(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
if !a.ready.Load() {
a.writeErr(w, reqID, 503, "unavailable", "shutting down")
return
}
ctx, cancel := dbCtx(r.Context())
defer cancel()
if err := a.db.Ping(ctx); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.writeJSON(w, 200, map[string]string{"status": "ok"})
}
func (a *App) readJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
reqID := reqIDFrom(r)
ct := r.Header.Get("Content-Type")
media := strings.ToLower(strings.TrimSpace(strings.Split(ct, ";")[0]))
if media != "application/json" {
a.writeErr(w, reqID, 415, "unsupported_media_type", "Content-Type must be application/json")
return false
}
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
if _, ok := err.(*http.MaxBytesError); ok {
a.writeErr(w, reqID, 413, "payload_too_large", "body too large")
return false
}
a.writeErr(w, reqID, 400, "invalid_request", "invalid json")
return false
}
var extra json.RawMessage
if err := dec.Decode(&extra); err != io.EOF {
a.writeErr(w, reqID, 400, "invalid_request", "invalid json")
return false
}
return true
}
func isBlank(s string) bool {
return strings.TrimSpace(s) == ""
}
func isUUID(s string) bool {
if len(s) != 36 {
return false
}
for i, c := range s {
switch i {
case 8, 13, 18, 23:
if c != '-' {
return false
}
default:
if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
return false
}
}
}
raw := strings.ReplaceAll(s, "-", "")
_, err := hex.DecodeString(raw)
return err == nil
}
func isPgCode(err error, code string) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == code
}
func userJSON(u *User) map[string]any {
return map[string]any{
"id": u.ID,
"username": u.Username,
"display_name": u.DisplayName,
"created_at": formatTime(u.CreatedAt),
}
}
func (a *App) getUserByID(ctx context.Context, id string) (*User, error) {
ctx, cancel := dbCtx(ctx)
defer cancel()
var u User
err := a.db.QueryRow(ctx, `
select id::text, username, display_name, password_hash, created_at
from users where id = $1::uuid`, id).Scan(
&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return &u, nil
}
func (a *App) authUser(w http.ResponseWriter, r *http.Request) (*User, string) {
token, ok := parseBearer(r.Header.Get("Authorization"))
if !ok {
a.writeUnauthorized(w, r, "Bearer")
return nil, ""
}
hash, hashHex := tokenHash(token)
if cs, hit := a.cache.GetSession(r.Context(), hashHex); hit {
u, err := a.getUserByID(r.Context(), cs.UserID)
if err != nil {
a.writeErr(w, reqIDFrom(r), 503, "unavailable", "database unavailable")
return nil, ""
}
if u == nil {
a.writeUnauthorized(w, r, "Bearer")
return nil, ""
}
return u, hashHex
}
ctx, cancel := dbCtx(r.Context())
defer cancel()
var userID string
var expiresAt time.Time
err := a.db.QueryRow(ctx, `
select user_id::text, expires_at from sessions
where token_hash = $1 and expires_at > now()`, hash).Scan(&userID, &expiresAt)
if errors.Is(err, pgx.ErrNoRows) {
a.writeUnauthorized(w, r, "Bearer")
return nil, ""
}
if err != nil {
a.writeErr(w, reqIDFrom(r), 503, "unavailable", "database unavailable")
return nil, ""
}
u, err := a.getUserByID(r.Context(), userID)
if err != nil {
a.writeErr(w, reqIDFrom(r), 503, "unavailable", "database unavailable")
return nil, ""
}
if u == nil {
a.writeUnauthorized(w, r, "Bearer")
return nil, ""
}
a.cache.SetSession(r.Context(), hashHex, userID, expiresAt)
return u, hashHex
}
func (a *App) handleCreateUser(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
var body struct {
Username *string `json:"username"`
DisplayName *string `json:"display_name"`
Password *string `json:"password"`
}
if !a.readJSON(w, r, &body) {
return
}
if body.Username == nil || body.DisplayName == nil || body.Password == nil {
a.writeErr(w, reqID, 400, "invalid_request", "username, display_name and password required")
return
}
username := *body.Username
display := *body.DisplayName
password := *body.Password
if !usernameRe.MatchString(username) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid username")
return
}
n := utf8.RuneCountInString(display)
if n < 1 || n > 100 || isBlank(display) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid display_name")
return
}
if !validPassword(password) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid password")
return
}
ph, err := hashPassword(password)
if err != nil {
a.writeErr(w, reqID, 500, "internal_error", "internal error")
return
}
id := newUUID()
createdAt := nowUTC()
ctx, cancel := dbCtx(r.Context())
defer cancel()
_, err = a.db.Exec(ctx, `
insert into users(id, username, display_name, password_hash, created_at)
values($1::uuid, $2, $3, $4, $5)`, id, username, display, ph, createdAt)
if isPgCode(err, "23505") {
a.writeErr(w, reqID, 409, "conflict", "username taken")
return
}
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.writeJSON(w, 201, map[string]any{
"id": id,
"username": username,
"display_name": display,
"created_at": formatTime(createdAt),
})
}
func (a *App) handleCreateSession(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
username, password, ok := parseBasic(r.Header.Get("Authorization"))
if !ok {
a.writeUnauthorized(w, r, "Basic")
return
}
if !usernameRe.MatchString(username) || !validPassword(password) {
a.writeUnauthorized(w, r, "Basic")
return
}
ctx, cancel := dbCtx(r.Context())
defer cancel()
var u User
err := a.db.QueryRow(ctx, `
select id::text, username, display_name, password_hash, created_at
from users where username = $1`, username).Scan(
&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt)
if errors.Is(err, pgx.ErrNoRows) {
a.writeUnauthorized(w, r, "Basic")
return
}
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
match, err := checkPassword(u.PasswordHash, password)
if err != nil || !match {
a.writeUnauthorized(w, r, "Basic")
return
}
token, hash, hashHex, err := newToken()
if err != nil {
a.writeErr(w, reqID, 500, "internal_error", "internal error")
return
}
createdAt := nowUTC()
expiresAt := createdAt.Add(a.sessionTTL)
_, err = a.db.Exec(ctx, `
insert into sessions(token_hash, user_id, created_at, expires_at)
values($1, $2::uuid, $3, $4)`, hash, u.ID, createdAt, expiresAt)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.cache.SetSession(r.Context(), hashHex, u.ID, expiresAt)
a.writeJSON(w, 201, map[string]any{
"token": token,
"token_type": "Bearer",
"expires_at": formatTime(expiresAt),
"user": userJSON(&u),
})
}
func (a *App) handleRevokeSession(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
token, ok := parseBearer(r.Header.Get("Authorization"))
if !ok {
a.writeUnauthorized(w, r, "Bearer")
return
}
hash, hashHex := tokenHash(token)
ctx, cancel := dbCtx(r.Context())
defer cancel()
tag, err := a.db.Exec(ctx, `
delete from sessions where token_hash = $1 and expires_at > now()`, hash)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.cache.DelSession(r.Context(), hashHex)
if tag.RowsAffected() == 0 {
a.writeUnauthorized(w, r, "Bearer")
return
}
w.Header().Set("X-Request-Id", reqID)
w.WriteHeader(204)
}
func (a *App) handleMe(w http.ResponseWriter, r *http.Request) {
u, _ := a.authUser(w, r)
if u == nil {
return
}
a.writeJSON(w, 200, userJSON(u))
}
func (a *App) handleCreateChat(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
u, _ := a.authUser(w, r)
if u == nil {
return
}
var body struct {
Title *string `json:"title"`
MemberIDs *[]string `json:"member_ids"`
}
if !a.readJSON(w, r, &body) {
return
}
if body.Title == nil || body.MemberIDs == nil {
a.writeErr(w, reqID, 400, "invalid_request", "title and member_ids required")
return
}
title := *body.Title
n := utf8.RuneCountInString(title)
if n < 1 || n > 100 || isBlank(title) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid title")
return
}
members := *body.MemberIDs
if len(members) < 1 || len(members) > 100 {
a.writeErr(w, reqID, 400, "invalid_request", "invalid member_ids")
return
}
seen := make(map[string]struct{}, len(members))
hasCaller := false
for _, id := range members {
if !isUUID(id) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid member id")
return
}
if _, dup := seen[id]; dup {
a.writeErr(w, reqID, 400, "invalid_request", "duplicate member")
return
}
seen[id] = struct{}{}
if id == u.ID {
hasCaller = true
}
}
if !hasCaller {
a.writeErr(w, reqID, 400, "invalid_request", "caller must be member")
return
}
chatID := newUUID()
createdAt := nowUTC()
ctx, cancel := dbCtx(r.Context())
defer cancel()
tx, err := a.db.Begin(ctx)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
defer tx.Rollback(ctx)
_, err = tx.Exec(ctx, `insert into chats(id, title, created_at) values($1::uuid, $2, $3)`,
chatID, title, createdAt)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
for _, mid := range members {
_, err = tx.Exec(ctx, `insert into chat_members(chat_id, user_id) values($1::uuid, $2::uuid)`,
chatID, mid)
if isPgCode(err, "23503") {
a.writeErr(w, reqID, 400, "invalid_request", "unknown member")
return
}
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
}
if err := tx.Commit(ctx); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.writeJSON(w, 201, map[string]any{
"id": chatID,
"title": title,
"member_ids": members,
"created_at": formatTime(createdAt),
})
}
func encodeCursor(parts ...string) string {
return base64.RawURLEncoding.EncodeToString([]byte(strings.Join(parts, "|")))
}
func decodeCursor(s string) ([]string, error) {
b, err := base64.RawURLEncoding.DecodeString(s)
if err != nil {
return nil, err
}
return strings.Split(string(b), "|"), nil
}
func parseLimit(r *http.Request) (int, error) {
q := r.URL.Query().Get("limit")
if q == "" {
return 50, nil
}
n, err := strconv.Atoi(q)
if err != nil || n < 1 || n > 100 {
return 0, fmt.Errorf("bad limit")
}
return n, nil
}
func (a *App) loadChatMembers(ctx context.Context, chatID string) ([]string, error) {
ctx, cancel := dbCtx(ctx)
defer cancel()
rows, err := a.db.Query(ctx, `
select user_id::text from chat_members where chat_id = $1::uuid order by user_id`, chatID)
if err != nil {
return nil, err
}
defer rows.Close()
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}
func (a *App) isMember(ctx context.Context, chatID, userID string) (bool, error) {
ctx, cancel := dbCtx(ctx)
defer cancel()
var ok bool
err := a.db.QueryRow(ctx, `
select exists(
select 1 from chat_members where chat_id = $1::uuid and user_id = $2::uuid
)`, chatID, userID).Scan(&ok)
return ok, err
}
func (a *App) handleListChats(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
u, _ := a.authUser(w, r)
if u == nil {
return
}
limit, err := parseLimit(r)
if err != nil {
a.writeErr(w, reqID, 400, "invalid_request", "invalid limit")
return
}
var afterTS *time.Time
var afterID string
if cur := r.URL.Query().Get("cursor"); cur != "" {
parts, err := decodeCursor(cur)
if err != nil || len(parts) != 3 {
a.writeErr(w, reqID, 400, "invalid_request", "invalid cursor")
return
}
if parts[0] != u.ID {
a.writeErr(w, reqID, 400, "invalid_request", "invalid cursor")
return
}
ts, err := parseTime(parts[1])
if err != nil || !isUUID(parts[2]) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid cursor")
return
}
afterTS = &ts
afterID = parts[2]
}
ctx, cancel := dbCtx(r.Context())
defer cancel()
var rows pgx.Rows
if afterTS == nil {
rows, err = a.db.Query(ctx, `
select c.id::text, c.title, c.created_at
from chats c
join chat_members m on m.chat_id = c.id
where m.user_id = $1::uuid
order by c.created_at, c.id
limit $2`, u.ID, limit+1)
} else {
rows, err = a.db.Query(ctx, `
select c.id::text, c.title, c.created_at
from chats c
join chat_members m on m.chat_id = c.id
where m.user_id = $1::uuid
and (c.created_at, c.id) > ($2, $3::uuid)
order by c.created_at, c.id
limit $4`, u.ID, *afterTS, afterID, limit+1)
}
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
defer rows.Close()
type row struct {
id, title string
created time.Time
}
var list []row
for rows.Next() {
var x row
if err := rows.Scan(&x.id, &x.title, &x.created); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
list = append(list, x)
}
if err := rows.Err(); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
hasMore := len(list) > limit
if hasMore {
list = list[:limit]
}
out := make([]map[string]any, 0, len(list))
for _, c := range list {
members, err := a.loadChatMembers(r.Context(), c.id)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
out = append(out, map[string]any{
"id": c.id,
"title": c.title,
"member_ids": members,
"created_at": formatTime(c.created),
})
}
var next any = nil
if hasMore && len(list) > 0 {
last := list[len(list)-1]
next = encodeCursor(u.ID, formatTime(last.created), last.id)
}
a.writeJSON(w, 200, map[string]any{"items": out, "next_cursor": next})
}
func (a *App) handleGetChat(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
u, _ := a.authUser(w, r)
if u == nil {
return
}
chatID := r.PathValue("chat_id")
if !isUUID(chatID) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid chat_id")
return
}
ok, err := a.isMember(r.Context(), chatID, u.ID)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
if !ok {
a.writeErr(w, reqID, 404, "not_found", "chat not found")
return
}
ctx, cancel := dbCtx(r.Context())
defer cancel()
var title string
var createdAt time.Time
err = a.db.QueryRow(ctx, `select title, created_at from chats where id = $1::uuid`, chatID).
Scan(&title, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
a.writeErr(w, reqID, 404, "not_found", "chat not found")
return
}
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
members, err := a.loadChatMembers(r.Context(), chatID)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.writeJSON(w, 200, map[string]any{
"id": chatID,
"title": title,
"member_ids": members,
"created_at": formatTime(createdAt),
})
}
func (a *App) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
u, _ := a.authUser(w, r)
if u == nil {
return
}
chatID := r.PathValue("chat_id")
if !isUUID(chatID) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid chat_id")
return
}
key := r.Header.Get("Idempotency-Key")
if !idempotencyKeyRe.MatchString(key) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid Idempotency-Key")
return
}
ok, err := a.isMember(r.Context(), chatID, u.ID)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
if !ok {
a.writeErr(w, reqID, 404, "not_found", "chat not found")
return
}
var body struct {
Text *string `json:"text"`
}
if !a.readJSON(w, r, &body) {
return
}
if body.Text == nil {
a.writeErr(w, reqID, 400, "invalid_request", "text required")
return
}
text := *body.Text
n := utf8.RuneCountInString(text)
if n < 1 || n > 4000 || isBlank(text) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid text")
return
}
sum := sha256.Sum256([]byte(text))
bodyHash := hex.EncodeToString(sum[:])
path := r.URL.Path
ctx, cancel := dbCtx(r.Context())
defer cancel()
tx, err := a.db.Begin(ctx)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
defer tx.Rollback(ctx)
if _, err := tx.Exec(ctx, `
delete from idempotency_keys
where user_id=$1::uuid and method='POST' and path=$2 and key=$3
and created_at < $4`,
u.ID, path, key, time.Now().Add(-a.idempotencyTTL)); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
msgID := newUUID()
createdAt := nowUTC()
resp := map[string]any{
"id": msgID,
"chat_id": chatID,
"sender_id": u.ID,
"text": text,
"created_at": formatTime(createdAt),
}
respJSON, _ := json.Marshal(resp)
tag, err := tx.Exec(ctx, `
insert into idempotency_keys(user_id, method, path, key, body_hash, response, created_at)
values($1::uuid, 'POST', $2, $3, $4, $5, $6)
on conflict do nothing`,
u.ID, path, key, bodyHash, respJSON, createdAt)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
if tag.RowsAffected() == 0 {
var storedHash string
var stored []byte
err := tx.QueryRow(ctx, `
select body_hash, response from idempotency_keys
where user_id=$1::uuid and method='POST' and path=$2 and key=$3`,
u.ID, path, key).Scan(&storedHash, &stored)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
if storedHash != bodyHash {
a.writeErr(w, reqID, 409, "conflict", "idempotency key reused with different body")
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(201)
_, _ = w.Write(append(stored, '\n'))
return
}
if _, err := tx.Exec(ctx, `
insert into messages(id, chat_id, sender_id, text, created_at)
values($1::uuid, $2::uuid, $3::uuid, $4, $5)`,
msgID, chatID, u.ID, text, createdAt); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
if err := tx.Commit(ctx); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
a.writeJSON(w, 201, resp)
}
func (a *App) handleListMessages(w http.ResponseWriter, r *http.Request) {
reqID := reqIDFrom(r)
u, _ := a.authUser(w, r)
if u == nil {
return
}
chatID := r.PathValue("chat_id")
if !isUUID(chatID) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid chat_id")
return
}
ok, err := a.isMember(r.Context(), chatID, u.ID)
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
if !ok {
a.writeErr(w, reqID, 404, "not_found", "chat not found")
return
}
limit, err := parseLimit(r)
if err != nil {
a.writeErr(w, reqID, 400, "invalid_request", "invalid limit")
return
}
var afterTS *time.Time
var afterID string
if cur := r.URL.Query().Get("cursor"); cur != "" {
parts, err := decodeCursor(cur)
if err != nil || len(parts) != 3 {
a.writeErr(w, reqID, 400, "invalid_request", "invalid cursor")
return
}
if parts[0] != chatID {
a.writeErr(w, reqID, 400, "invalid_request", "invalid cursor")
return
}
ts, err := parseTime(parts[1])
if err != nil || !isUUID(parts[2]) {
a.writeErr(w, reqID, 400, "invalid_request", "invalid cursor")
return
}
afterTS = &ts
afterID = parts[2]
}
ctx, cancel := dbCtx(r.Context())
defer cancel()
var rows pgx.Rows
if afterTS == nil {
rows, err = a.db.Query(ctx, `
select id::text, chat_id::text, sender_id::text, text, created_at
from messages
where chat_id = $1::uuid
order by created_at, id
limit $2`, chatID, limit+1)
} else {
rows, err = a.db.Query(ctx, `
select id::text, chat_id::text, sender_id::text, text, created_at
from messages
where chat_id = $1::uuid
and (created_at, id) > ($2, $3::uuid)
order by created_at, id
limit $4`, chatID, *afterTS, afterID, limit+1)
}
if err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
defer rows.Close()
type row struct {
id, chatID, senderID, text string
created time.Time
}
var list []row
for rows.Next() {
var x row
if err := rows.Scan(&x.id, &x.chatID, &x.senderID, &x.text, &x.created); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
list = append(list, x)
}
if err := rows.Err(); err != nil {
a.writeErr(w, reqID, 503, "unavailable", "database unavailable")
return
}
hasMore := len(list) > limit
if hasMore {
list = list[:limit]
}
out := make([]map[string]any, 0, len(list))
for _, m := range list {
out = append(out, map[string]any{
"id": m.id,
"chat_id": m.chatID,
"sender_id": m.senderID,
"text": m.text,
"created_at": formatTime(m.created),
})
}
var next any = nil
if hasMore && len(list) > 0 {
last := list[len(list)-1]
next = encodeCursor(chatID, formatTime(last.created), last.id)
}
a.writeJSON(w, 200, map[string]any{"items": out, "next_cursor": next})
}
func envOr(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
+89
View File
@@ -0,0 +1,89 @@
package main
import (
"context"
"log/slog"
"net"
"net/http"
"os"
"os/signal"
"strconv"
"syscall"
"time"
)
func main() {
log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
host := envOr("APP_HOST", "0.0.0.0")
port := envOr("APP_PORT", "8080")
shutdownSec, _ := strconv.Atoi(envOr("SHUTDOWN_TIMEOUT_SECONDS", "5"))
if shutdownSec < 1 {
shutdownSec = 5
}
ttlSec, _ := strconv.Atoi(envOr("SESSION_TTL_SECONDS", "3600"))
if ttlSec < 1 {
ttlSec = 3600
}
idemSec, _ := strconv.Atoi(envOr("IDEMPOTENCY_TTL_SECONDS", "86400"))
if idemSec < 1 {
idemSec = 86400
}
drainSec, _ := strconv.Atoi(envOr("DRAIN_SECONDS", "3"))
ctx := context.Background()
db, err := openDB(ctx)
if err != nil {
log.Error("database open failed", "err", err.Error())
os.Exit(1)
}
defer db.Close()
if len(os.Args) > 1 && os.Args[1] == "migrate" {
if err := migrate(ctx, db); err != nil {
log.Error("migrate failed", "err", err.Error())
os.Exit(1)
}
log.Info("migrations applied")
return
}
cache := openCache(log)
defer cache.Close()
app := NewApp(db, cache, log, time.Duration(ttlSec)*time.Second, time.Duration(idemSec)*time.Second)
addr := net.JoinHostPort(host, port)
srv := &http.Server{
Addr: addr,
Handler: app.Routes(),
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 10 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 30 * time.Second,
}
go func() {
log.Info("listening", "addr", addr, "env", envOr("APP_ENV", "lab"), "session_ttl_s", ttlSec)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Error("server error", "err", err.Error())
os.Exit(1)
}
}()
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
sig := <-stop
log.Info("shutdown started", "signal", sig.String())
app.SetReady(false)
time.Sleep(time.Duration(drainSec) * time.Second)
shCtx, cancel := context.WithTimeout(context.Background(), time.Duration(shutdownSec)*time.Second)
defer cancel()
if err := srv.Shutdown(shCtx); err != nil {
log.Error("shutdown error", "err", err.Error())
os.Exit(1)
}
log.Info("shutdown finished")
}
+84
View File
@@ -0,0 +1,84 @@
package main
import (
"context"
"embed"
"fmt"
"sort"
"strings"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
//go:embed migrations/*.sql
var migrationFS embed.FS
func migrate(ctx context.Context, pool *pgxpool.Pool) error {
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
conn, err := pool.Acquire(ctx)
if err != nil {
return err
}
defer conn.Release()
if _, err := conn.Exec(ctx, `select pg_advisory_lock(727001)`); err != nil {
return err
}
defer conn.Exec(context.Background(), `select pg_advisory_unlock(727001)`)
_, err = conn.Exec(ctx, `
create table if not exists schema_migrations (
version text primary key,
applied_at timestamptz not null
)`)
if err != nil {
return fmt.Errorf("schema_migrations: %w", err)
}
entries, err := migrationFS.ReadDir("migrations")
if err != nil {
return err
}
var names []string
for _, e := range entries {
if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") {
names = append(names, e.Name())
}
}
sort.Strings(names)
for _, name := range names {
var exists bool
err := conn.QueryRow(ctx, `select exists(select 1 from schema_migrations where version=$1)`, name).Scan(&exists)
if err != nil {
return err
}
if exists {
continue
}
body, err := migrationFS.ReadFile("migrations/" + name)
if err != nil {
return err
}
tx, err := conn.Begin(ctx)
if err != nil {
return err
}
if _, err := tx.Exec(ctx, string(body)); err != nil {
_ = tx.Rollback(ctx)
return fmt.Errorf("migration %s: %w", name, err)
}
if _, err := tx.Exec(ctx, `insert into schema_migrations(version, applied_at) values($1, now())`, name); err != nil {
_ = tx.Rollback(ctx)
return err
}
if err := tx.Commit(ctx); err != nil {
return err
}
}
return nil
}
+38
View File
@@ -0,0 +1,38 @@
create table users (
id uuid primary key,
username text not null unique,
display_name text not null,
password_hash text not null,
created_at timestamptz not null
);
create table chats (
id uuid primary key,
title text not null,
created_at timestamptz not null
);
create table chat_members (
chat_id uuid not null references chats(id),
user_id uuid not null references users(id),
primary key (chat_id, user_id)
);
create index chat_members_user_idx on chat_members (user_id);
create table messages (
id uuid primary key,
chat_id uuid not null references chats(id),
sender_id uuid not null references users(id),
text text not null,
created_at timestamptz not null
);
create index messages_history_idx on messages (chat_id, created_at, id);
create table sessions (
token_hash bytea primary key,
user_id uuid not null references users(id) on delete cascade,
created_at timestamptz not null,
expires_at timestamptz not null
);
+10
View File
@@ -0,0 +1,10 @@
create table idempotency_keys (
user_id uuid not null references users(id) on delete cascade,
method text not null,
path text not null,
key text not null,
body_hash text not null,
response jsonb not null,
created_at timestamptz not null,
primary key (user_id, method, path, key)
);
+33
View File
@@ -0,0 +1,33 @@
package main
import "time"
type User struct {
ID string
Username string
DisplayName string
PasswordHash string
CreatedAt time.Time
}
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
type Message struct {
ID string
ChatID string
SenderID string
Text string
CreatedAt time.Time
}
type Session struct {
TokenHash []byte
UserID string
CreatedAt time.Time
ExpiresAt time.Time
}