forked from mtusi2026/mtusi2026lab2
572 lines
18 KiB
Go
572 lines
18 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"sync/atomic"
|
|
"syscall"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"github.com/lib/pq"
|
|
"github.com/redis/go-redis/v9"
|
|
"mtusi2026lab2/models"
|
|
)
|
|
|
|
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
|
|
var uuidPattern = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
|
|
|
|
type cacheMetrics struct{ hits, misses, failures atomic.Uint64 }
|
|
type app struct {
|
|
store *store
|
|
limits limits
|
|
metrics metrics
|
|
cacheMetrics cacheMetrics
|
|
gate, kdfGate chan struct{}
|
|
ttl time.Duration
|
|
timeout time.Duration
|
|
dummyHash string
|
|
}
|
|
type createUser struct {
|
|
Username string `json:"username"`
|
|
DisplayName string `json:"display_name"`
|
|
Password string `json:"password"`
|
|
}
|
|
type createChat struct {
|
|
Title string `json:"title"`
|
|
MemberIDs []models.UUID `json:"member_ids"`
|
|
}
|
|
type createMessage struct {
|
|
Text string `json:"text"`
|
|
}
|
|
type cursor struct {
|
|
Resource string `json:"resource"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
ID models.UUID `json:"id"`
|
|
}
|
|
|
|
func setting(name, fallback string) string {
|
|
if value := os.Getenv(name); value != "" {
|
|
return value
|
|
}
|
|
return fallback
|
|
}
|
|
func secret(name string) string {
|
|
if path := os.Getenv(name + "_FILE"); path != "" {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
log.Fatalf("cannot read %s_FILE", name)
|
|
}
|
|
return strings.TrimSpace(string(data))
|
|
}
|
|
return os.Getenv(name)
|
|
}
|
|
|
|
func main() {
|
|
if setting("SESSION_STORE", "postgres") != "postgres" {
|
|
log.Fatal("this implementation uses PostgreSQL sessions")
|
|
}
|
|
db, err := sql.Open("postgres", secret("DATABASE_URL"))
|
|
if err != nil {
|
|
log.Fatal("invalid database configuration")
|
|
}
|
|
defer db.Close()
|
|
pool := envInt("DB_MAX_CONNECTIONS", 8, 1)
|
|
db.SetMaxOpenConns(pool)
|
|
db.SetMaxIdleConns(pool)
|
|
db.SetConnMaxLifetime(30 * time.Minute)
|
|
bootCtx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
|
|
if err = migrate(bootCtx, db); err != nil {
|
|
cancel()
|
|
log.Fatal("database migration failed: ", err)
|
|
}
|
|
cancel()
|
|
configuration := loadLimits()
|
|
a := &app{store: &store{db: db}, limits: configuration, gate: make(chan struct{}, configuration.maxInFlight), kdfGate: make(chan struct{}, envInt("KDF_CONCURRENCY", 4, 1)), ttl: time.Duration(envInt("SESSION_TTL_SECONDS", 3600, 1)) * time.Second, timeout: time.Duration(envInt("DB_TIMEOUT_MS", 2000, 100)) * time.Millisecond, dummyHash: hashPassword("dummy-never-a-login-password")}
|
|
if url := secret("CACHE_URL"); url != "" {
|
|
options, err := redis.ParseURL(url)
|
|
if err != nil {
|
|
log.Fatal("invalid cache configuration")
|
|
}
|
|
options.PoolSize = pool
|
|
options.MaxRetries = -1
|
|
options.DialTimeout = 150 * time.Millisecond
|
|
options.ReadTimeout = 150 * time.Millisecond
|
|
options.WriteTimeout = 150 * time.Millisecond
|
|
options.PoolTimeout = 150 * time.Millisecond
|
|
options.ContextTimeoutEnabled = true
|
|
a.store.cache = redis.NewClient(options)
|
|
a.store.metrics = &a.cacheMetrics
|
|
defer a.store.cache.Close()
|
|
}
|
|
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
|
defer stop()
|
|
go func() {
|
|
ticker := time.NewTicker(time.Minute)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-rootCtx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
ctx, cancel := context.WithTimeout(rootCtx, a.timeout)
|
|
_, _ = db.ExecContext(ctx, `DELETE FROM sessions WHERE expires_at<=clock_timestamp()`)
|
|
cancel()
|
|
}
|
|
}
|
|
}()
|
|
server := &http.Server{Addr: net.JoinHostPort(setting("APP_HOST", "0.0.0.0"), setting("APP_PORT", "8080")), Handler: a.routes(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, WriteTimeout: 15 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 16 * 1024}
|
|
serverErrors := make(chan error, 1)
|
|
go func() { log.Printf("server listening on %s", server.Addr); serverErrors <- server.ListenAndServe() }()
|
|
select {
|
|
case err := <-serverErrors:
|
|
if err != nil && err != http.ErrServerClosed {
|
|
log.Fatal(err)
|
|
}
|
|
case <-rootCtx.Done():
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := server.Shutdown(ctx); err != nil {
|
|
_ = server.Close()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (a *app) routes() http.Handler {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("GET /health/live", a.health)
|
|
mux.HandleFunc("GET /health/ready", a.health)
|
|
mux.HandleFunc("GET /metrics", a.metricsHandler)
|
|
mux.HandleFunc("POST /api/v1/users", a.users)
|
|
mux.HandleFunc("POST /api/v1/auth/sessions", a.login)
|
|
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", a.logout)
|
|
mux.HandleFunc("GET /api/v1/users/me", a.currentUser)
|
|
mux.HandleFunc("/api/v1/chats", a.chats)
|
|
mux.HandleFunc("/api/v1/chats/", a.chatResource)
|
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
a.error(w, 404, "not_found", "Объект не найден")
|
|
})
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Header().Set("X-Request-Id", newID())
|
|
a.metrics.requests.Add(1)
|
|
if r.ContentLength > a.limits.maxBodyBytes {
|
|
a.metrics.status413.Add(1)
|
|
a.error(w, 413, "payload_too_large", "Размер запроса превышает лимит")
|
|
return
|
|
}
|
|
// Health and metrics remain observable while the business admission gate is full.
|
|
if !strings.HasPrefix(r.URL.Path, "/health/") && r.URL.Path != "/metrics" {
|
|
select {
|
|
case a.gate <- struct{}{}:
|
|
a.metrics.inFlight.Add(1)
|
|
defer func() { <-a.gate; a.metrics.inFlight.Add(-1) }()
|
|
default:
|
|
a.rateLimited(w)
|
|
return
|
|
}
|
|
}
|
|
defer func() {
|
|
if recover() != nil {
|
|
a.error(w, 500, "internal_error", "Внутренняя ошибка")
|
|
}
|
|
}()
|
|
ctx, cancel := context.WithTimeout(r.Context(), a.timeout)
|
|
defer cancel()
|
|
mux.ServeHTTP(w, r.WithContext(ctx))
|
|
})
|
|
}
|
|
|
|
func (a *app) error(w http.ResponseWriter, status int, code, message string) {
|
|
writeJSON(w, status, map[string]any{"error": map[string]string{"code": code, "message": message, "request_id": w.Header().Get("X-Request-Id")}})
|
|
}
|
|
func (a *app) unavailable(w http.ResponseWriter) {
|
|
a.metrics.status503.Add(1)
|
|
a.error(w, 503, "unavailable", "Хранилище временно недоступно")
|
|
}
|
|
func (a *app) unauthorized(w http.ResponseWriter, basic bool) {
|
|
scheme := `Bearer realm="messenger"`
|
|
if basic {
|
|
scheme = `Basic realm="messenger", charset="UTF-8"`
|
|
}
|
|
w.Header().Set("WWW-Authenticate", scheme)
|
|
a.error(w, 401, "unauthorized", "Нет действительной аутентификации")
|
|
}
|
|
func (a *app) rateLimited(w http.ResponseWriter) {
|
|
w.Header().Set("Retry-After", "1")
|
|
a.metrics.status429.Add(1)
|
|
a.error(w, 429, "rate_limited", "Слишком много запросов")
|
|
}
|
|
func (a *app) kdf(w http.ResponseWriter) bool {
|
|
select {
|
|
case a.kdfGate <- struct{}{}:
|
|
return true
|
|
default:
|
|
a.rateLimited(w)
|
|
return false
|
|
}
|
|
}
|
|
func (a *app) decode(w http.ResponseWriter, r *http.Request, target any) bool {
|
|
data, err := io.ReadAll(http.MaxBytesReader(w, r.Body, a.limits.maxBodyBytes))
|
|
if err != nil {
|
|
var large *http.MaxBytesError
|
|
if errors.As(err, &large) {
|
|
a.metrics.status413.Add(1)
|
|
a.error(w, 413, "payload_too_large", "Размер запроса превышает лимит")
|
|
} else {
|
|
a.error(w, 400, "invalid_request", "Неверный JSON")
|
|
}
|
|
return false
|
|
}
|
|
decoder := json.NewDecoder(bytes.NewReader(data))
|
|
decoder.DisallowUnknownFields()
|
|
var extra any
|
|
if !utf8.Valid(data) || decoder.Decode(target) != nil || decoder.Decode(&extra) != io.EOF {
|
|
a.error(w, 400, "invalid_request", "Неверный JSON")
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (a *app) health(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path == "/health/ready" && a.store.db.PingContext(r.Context()) != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
writeJSON(w, 200, map[string]string{"status": "ok"})
|
|
}
|
|
func (a *app) metricsHandler(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "text/plain; version=0.0.4")
|
|
_, _ = fmt.Fprint(w, a.metrics.snapshot())
|
|
_, _ = fmt.Fprintf(w, "messenger_profile_cache_hits_total %d\nmessenger_profile_cache_misses_total %d\nmessenger_profile_cache_failures_total %d\nmessenger_db_connections %d\n", a.cacheMetrics.hits.Load(), a.cacheMetrics.misses.Load(), a.cacheMetrics.failures.Load(), a.store.db.Stats().OpenConnections)
|
|
}
|
|
|
|
func (a *app) users(w http.ResponseWriter, r *http.Request) {
|
|
var input createUser
|
|
if !a.decode(w, r, &input) {
|
|
return
|
|
}
|
|
if !usernamePattern.MatchString(input.Username) || !validText(input.DisplayName, 100) || !validPassword(input.Password) {
|
|
a.error(w, 400, "invalid_request", "Неверные поля пользователя")
|
|
return
|
|
}
|
|
if !a.kdf(w) {
|
|
return
|
|
}
|
|
hash := hashPassword(input.Password)
|
|
<-a.kdfGate
|
|
user, err := scanUser(a.store.db.QueryRowContext(r.Context(), `INSERT INTO users(id,username,display_name,password_hash) VALUES($1,$2,$3,$4) RETURNING id,username,display_name,created_at`, newID(), input.Username, input.DisplayName, hash))
|
|
if err != nil {
|
|
var pg *pq.Error
|
|
if errors.As(err, &pg) && pg.Code == "23505" {
|
|
a.error(w, 409, "conflict", "Имя пользователя уже занято")
|
|
} else {
|
|
a.unavailable(w)
|
|
}
|
|
return
|
|
}
|
|
writeJSON(w, 201, user)
|
|
}
|
|
|
|
func (a *app) login(w http.ResponseWriter, r *http.Request) {
|
|
data, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1))
|
|
if err != nil || len(data) != 0 {
|
|
a.error(w, 400, "invalid_request", "Вход не принимает тело запроса")
|
|
return
|
|
}
|
|
username, password, ok := r.BasicAuth()
|
|
if !ok || !usernamePattern.MatchString(username) || !validPassword(password) {
|
|
a.unauthorized(w, true)
|
|
return
|
|
}
|
|
var user models.User
|
|
var hash string
|
|
err = a.store.db.QueryRowContext(r.Context(), `SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=$1`, username).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt, &hash)
|
|
missing := errors.Is(err, sql.ErrNoRows)
|
|
if err != nil && !missing {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
if missing {
|
|
hash = a.dummyHash
|
|
}
|
|
if !a.kdf(w) {
|
|
return
|
|
}
|
|
valid := verifyPassword(hash, password)
|
|
<-a.kdfGate
|
|
if !valid || missing {
|
|
a.unauthorized(w, true)
|
|
return
|
|
}
|
|
data = make([]byte, 32)
|
|
if _, err = rand.Read(data); err != nil {
|
|
panic(err)
|
|
}
|
|
token := base64.RawURLEncoding.EncodeToString(data)
|
|
digest := sha256.Sum256([]byte(token))
|
|
var expires time.Time
|
|
err = a.store.db.QueryRowContext(r.Context(), `INSERT INTO sessions(token_hash,user_id,expires_at) VALUES($1,$2,clock_timestamp()+$3*interval '1 second') RETURNING expires_at`, digest[:], user.ID, int(a.ttl/time.Second)).Scan(&expires)
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
user.CreatedAt = user.CreatedAt.UTC()
|
|
writeJSON(w, 201, map[string]any{"token": token, "token_type": "Bearer", "expires_at": expires.UTC(), "user": user})
|
|
}
|
|
|
|
func bearer(r *http.Request) string {
|
|
parts := strings.Fields(r.Header.Get("Authorization"))
|
|
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") || len(parts[1]) != 43 {
|
|
return ""
|
|
}
|
|
data, err := base64.RawURLEncoding.DecodeString(parts[1])
|
|
if err != nil || len(data) != 32 {
|
|
return ""
|
|
}
|
|
return parts[1]
|
|
}
|
|
func (a *app) authenticate(w http.ResponseWriter, r *http.Request) (models.UUID, bool) {
|
|
token := bearer(r)
|
|
if token == "" {
|
|
a.unauthorized(w, false)
|
|
return "", false
|
|
}
|
|
digest := sha256.Sum256([]byte(token))
|
|
var user models.UUID
|
|
err := a.store.db.QueryRowContext(r.Context(), `SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp()`, digest[:]).Scan(&user)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
a.unauthorized(w, false)
|
|
return "", false
|
|
}
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return "", false
|
|
}
|
|
return user, true
|
|
}
|
|
func (a *app) logout(w http.ResponseWriter, r *http.Request) {
|
|
token := bearer(r)
|
|
if token == "" {
|
|
a.unauthorized(w, false)
|
|
return
|
|
}
|
|
digest := sha256.Sum256([]byte(token))
|
|
var id models.UUID
|
|
err := a.store.db.QueryRowContext(r.Context(), `DELETE FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp() RETURNING user_id`, digest[:]).Scan(&id)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
a.unauthorized(w, false)
|
|
return
|
|
}
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
w.WriteHeader(204)
|
|
}
|
|
func (a *app) currentUser(w http.ResponseWriter, r *http.Request) {
|
|
id, ok := a.authenticate(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
u, err := a.store.user(r.Context(), id)
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
writeJSON(w, 200, u)
|
|
}
|
|
|
|
func (a *app) chats(w http.ResponseWriter, r *http.Request) {
|
|
user, ok := a.authenticate(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if r.Method == http.MethodPost {
|
|
var input createChat
|
|
if !a.decode(w, r, &input) {
|
|
return
|
|
}
|
|
if !validText(input.Title, 100) || len(input.MemberIDs) < 1 || len(input.MemberIDs) > 100 {
|
|
a.error(w, 400, "invalid_request", "Неверные поля чата")
|
|
return
|
|
}
|
|
seen := map[models.UUID]bool{}
|
|
for i, id := range input.MemberIDs {
|
|
id = models.UUID(strings.ToLower(string(id)))
|
|
if !isUUID(string(id)) || seen[id] {
|
|
a.error(w, 400, "invalid_request", "Неверные участники")
|
|
return
|
|
}
|
|
seen[id] = true
|
|
input.MemberIDs[i] = id
|
|
}
|
|
if !seen[user] {
|
|
a.error(w, 400, "invalid_request", "Создатель должен быть участником")
|
|
return
|
|
}
|
|
chat, err := a.store.createChat(r.Context(), input.Title, input.MemberIDs)
|
|
if err != nil {
|
|
var pg *pq.Error
|
|
if errors.As(err, &pg) && pg.Code == "23503" {
|
|
a.error(w, 400, "invalid_request", "Неизвестный участник")
|
|
} else {
|
|
a.unavailable(w)
|
|
}
|
|
return
|
|
}
|
|
writeJSON(w, 201, chat)
|
|
return
|
|
}
|
|
if r.Method != http.MethodGet {
|
|
a.error(w, 404, "not_found", "Объект не найден")
|
|
return
|
|
}
|
|
resource := "chats:" + string(user)
|
|
p, limit, ok := a.position(w, r, resource)
|
|
if !ok {
|
|
return
|
|
}
|
|
items, err := a.store.chats(r.Context(), user, p, limit)
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
var next any
|
|
if len(items) > limit {
|
|
items = items[:limit]
|
|
last := items[len(items)-1]
|
|
next = encodeCursor(cursor{resource, last.CreatedAt, last.ID})
|
|
}
|
|
writeJSON(w, 200, map[string]any{"items": items, "next_cursor": next})
|
|
}
|
|
|
|
func (a *app) chatResource(w http.ResponseWriter, r *http.Request) {
|
|
user, ok := a.authenticate(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
parts := strings.Split(strings.TrimPrefix(r.URL.Path, "/api/v1/chats/"), "/")
|
|
if !isUUID(parts[0]) {
|
|
a.error(w, 400, "invalid_request", "Неверный UUID")
|
|
return
|
|
}
|
|
chatID := models.UUID(strings.ToLower(parts[0]))
|
|
chat, err := a.store.chat(r.Context(), chatID, user)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
a.error(w, 404, "not_found", "Объект не найден")
|
|
return
|
|
}
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
if len(parts) == 1 && r.Method == http.MethodGet {
|
|
writeJSON(w, 200, chat)
|
|
return
|
|
}
|
|
if len(parts) != 2 || parts[1] != "messages" {
|
|
a.error(w, 404, "not_found", "Объект не найден")
|
|
return
|
|
}
|
|
if r.Method == http.MethodPost {
|
|
var input createMessage
|
|
if !a.decode(w, r, &input) {
|
|
return
|
|
}
|
|
if !validText(input.Text, 4000) {
|
|
a.error(w, 400, "invalid_request", "Неверный текст")
|
|
return
|
|
}
|
|
m := models.Message{ID: models.UUID(newID()), ChatID: chatID, SenderID: user, Text: input.Text}
|
|
err = a.store.db.QueryRowContext(r.Context(), `INSERT INTO messages(id,chat_id,sender_id,text) VALUES($1,$2,$3,$4) RETURNING created_at`, m.ID, chatID, user, input.Text).Scan(&m.CreatedAt)
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
m.CreatedAt = m.CreatedAt.UTC()
|
|
a.metrics.accepted.Add(1)
|
|
writeJSON(w, 201, m)
|
|
return
|
|
}
|
|
if r.Method != http.MethodGet {
|
|
a.error(w, 404, "not_found", "Объект не найден")
|
|
return
|
|
}
|
|
resource := "messages:" + string(chatID)
|
|
p, limit, ok := a.position(w, r, resource)
|
|
if !ok {
|
|
return
|
|
}
|
|
items, err := a.store.messages(r.Context(), chatID, p, limit)
|
|
if err != nil {
|
|
a.unavailable(w)
|
|
return
|
|
}
|
|
var next any
|
|
if len(items) > limit {
|
|
items = items[:limit]
|
|
last := items[len(items)-1]
|
|
next = encodeCursor(cursor{resource, last.CreatedAt, last.ID})
|
|
}
|
|
writeJSON(w, 200, map[string]any{"items": items, "next_cursor": next})
|
|
}
|
|
|
|
func (a *app) position(w http.ResponseWriter, r *http.Request, resource string) (cursor, int, bool) {
|
|
limit := 50
|
|
var err error
|
|
if value := r.URL.Query().Get("limit"); value != "" {
|
|
limit, err = strconv.Atoi(value)
|
|
}
|
|
p := cursor{Resource: resource, CreatedAt: time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC), ID: "00000000-0000-0000-0000-000000000000"}
|
|
if limit < 1 || limit > 100 || err != nil {
|
|
a.error(w, 400, "invalid_request", "Неверный limit")
|
|
return p, 0, false
|
|
}
|
|
if value := r.URL.Query().Get("cursor"); value != "" {
|
|
data, e := base64.RawURLEncoding.DecodeString(value)
|
|
if len(value) > 1024 || e != nil || json.Unmarshal(data, &p) != nil || p.Resource != resource || !isUUID(string(p.ID)) || p.CreatedAt.IsZero() {
|
|
a.error(w, 400, "invalid_request", "Неверный cursor")
|
|
return p, 0, false
|
|
}
|
|
}
|
|
return p, limit, true
|
|
}
|
|
func encodeCursor(p cursor) string {
|
|
data, _ := json.Marshal(p)
|
|
return base64.RawURLEncoding.EncodeToString(data)
|
|
}
|
|
func validText(value string, max int) bool {
|
|
return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= max
|
|
}
|
|
func isUUID(value string) bool { return uuidPattern.MatchString(value) }
|
|
func writeJSON(w http.ResponseWriter, status int, value any) {
|
|
w.WriteHeader(status)
|
|
_ = json.NewEncoder(w).Encode(value)
|
|
}
|
|
func newID() string {
|
|
data := make([]byte, 16)
|
|
if _, err := rand.Read(data); err != nil {
|
|
panic(err)
|
|
}
|
|
data[6] = (data[6] & 0x0f) | 0x40
|
|
data[8] = (data[8] & 0x3f) | 0x80
|
|
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", data[:4], data[4:6], data[6:8], data[8:10], data[10:])
|
|
}
|