Ilia Denisov
408da3f201
New public ingress and the first network edge. Framework + a vertical slice of operations end-to-end; remaining ops reuse the same transcode pattern in Stage 7. Contracts (new module scrabble/pkg): - push.proto (backend->gateway gRPC server-stream) + scrabble.fbs (FlatBuffers edge payloads), committed generated Go; buf/flatc Makefiles (dev-time codegen). Backend: - REST handlers on the /api/v1 groups: internal session endpoints (telegram/guest/email login -> mint, resolve, revoke) and the user slice (profile, submit_play, state, lobby enqueue/poll, chat). - internal/notify in-process Publisher hub + internal/pushgrpc gRPC server (BACKEND_GRPC_ADDR) streaming your_turn/opponent_moved/chat/nudge/match_found; emission in game.commit, social, matchmaker. - migration 00005 accounts.is_guest; guests are durable rows excluded from stats; ProvisionGuest; email-as-login (RequestLoginCode/LoginWithCode). Gateway (new module scrabble/gateway): - Connect Gateway service over h2c (Execute + Subscribe), FlatBuffers<->JSON transcode registry, Telegram initData HMAC validator (seam), session cache, token-bucket rate limiter (3 classes), push fan-out hub, backend REST + push gRPC client, admin Basic-Auth reverse proxy. go.work: use ./pkg, ./gateway + replace scrabble/pkg. CI: gateway/**, pkg/** path filters; unit build/vet/test span all three modules. Docs (PLAN, ARCHITECTURE, FUNCTIONAL+ru, TESTING, READMEs) updated; gateway/pkg unit tests + guest/email-login integration tests.
109 lines
2.7 KiB
Go
109 lines
2.7 KiB
Go
// Package session is the gateway's in-memory session cache. It maps an opaque
|
|
// bearer token to the backend account id, falling back to the backend's resolve
|
|
// endpoint on a miss and caching the result for a bounded TTL. The backend
|
|
// remains the source of truth (sessions are revoke-only there); the cache only
|
|
// shortcuts the hot path.
|
|
package session
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Resolver resolves a token to an account id at the backend (the cache miss
|
|
// path). backendclient.Client satisfies it.
|
|
type Resolver interface {
|
|
ResolveSession(ctx context.Context, token string) (string, error)
|
|
}
|
|
|
|
// Cache resolves session tokens to account ids, caching hits for ttl.
|
|
type Cache struct {
|
|
backend Resolver
|
|
ttl time.Duration
|
|
max int
|
|
now func() time.Time
|
|
|
|
mu sync.Mutex
|
|
entries map[string]entry
|
|
}
|
|
|
|
type entry struct {
|
|
userID string
|
|
expires time.Time
|
|
}
|
|
|
|
// NewCache constructs a Cache over backend with the given TTL and maximum size.
|
|
func NewCache(backend Resolver, ttl time.Duration, max int) *Cache {
|
|
if max <= 0 {
|
|
max = 1
|
|
}
|
|
return &Cache{
|
|
backend: backend,
|
|
ttl: ttl,
|
|
max: max,
|
|
now: func() time.Time { return time.Now() },
|
|
entries: make(map[string]entry),
|
|
}
|
|
}
|
|
|
|
// Resolve returns the account id for token, consulting the cache first and the
|
|
// backend on a miss (caching the result). An empty token is rejected by the
|
|
// backend like any unknown token.
|
|
func (c *Cache) Resolve(ctx context.Context, token string) (string, error) {
|
|
if uid, ok := c.lookup(token); ok {
|
|
return uid, nil
|
|
}
|
|
uid, err := c.backend.ResolveSession(ctx, token)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
c.store(token, uid)
|
|
return uid, nil
|
|
}
|
|
|
|
// Invalidate drops a token from the cache (e.g. after a revoke).
|
|
func (c *Cache) Invalidate(token string) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
delete(c.entries, token)
|
|
}
|
|
|
|
// lookup returns a live cached account id for token.
|
|
func (c *Cache) lookup(token string) (string, bool) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
e, ok := c.entries[token]
|
|
if !ok || !c.now().Before(e.expires) {
|
|
return "", false
|
|
}
|
|
return e.userID, true
|
|
}
|
|
|
|
// store caches token -> userID, sweeping expired entries and bounding the size.
|
|
func (c *Cache) store(token, userID string) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if len(c.entries) >= c.max {
|
|
c.evictLocked()
|
|
}
|
|
c.entries[token] = entry{userID: userID, expires: c.now().Add(c.ttl)}
|
|
}
|
|
|
|
// evictLocked removes expired entries and, if still at capacity, drops arbitrary
|
|
// entries until below the limit. The caller holds c.mu.
|
|
func (c *Cache) evictLocked() {
|
|
now := c.now()
|
|
for k, e := range c.entries {
|
|
if !now.Before(e.expires) {
|
|
delete(c.entries, k)
|
|
}
|
|
}
|
|
for k := range c.entries {
|
|
if len(c.entries) < c.max {
|
|
break
|
|
}
|
|
delete(c.entries, k)
|
|
}
|
|
}
|