Ilia Denisov
52f898ca6f
Tests · Go / test (push) Successful in 7s
Tests · Integration / integration (push) Successful in 11s
Tests · UI / test (push) Successful in 20s
Tests · Go / test (pull_request) Successful in 6s
Tests · Integration / integration (pull_request) Successful in 11s
Tests · UI / test (pull_request) Successful in 19s
Link an email (confirm-code) or Telegram (web Login Widget) to the current account; if the identity already has its own account, merge the two into the one in use (the current account is primary, except a guest initiator whose durable counterpart wins). The merge runs in one transaction (internal/accountmerge): stats + hint wallet summed, paid_account ORed, identities/games/chat/complaints transferred, friends/blocks de-duplicated, the secondary kept as a merged_into tombstone so a shared finished game's no-cascade FKs hold; a shared active game blocks the merge. - migration 00009: accounts.paid_account, merged_into, merged_at (+ jetgen) - internal/link orchestrator; session.RevokeAllForAccount on merge - connector ValidateLoginWidget RPC + loginwidget HMAC validator - edge ops link.email.request/confirm/merge, link.telegram.confirm/merge; supersedes the Stage 8 email.bind.* surface (request never reveals 'taken' before the code is verified, so a probe cannot enumerate addresses) - UI Profile link section + irreversible-merge dialog; Telegram web sign-in - focused regression tests (merge core, guest inversion, active-game refusal, finished-shared-game kept), gateway transcode + connector + UI codec/e2e - docs: PLAN, ARCHITECTURE 3/4/9, FUNCTIONAL(+ru), module READMEs
114 lines
2.8 KiB
Go
114 lines
2.8 KiB
Go
package session
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// Cache is the in-memory write-through projection of the active rows in
|
|
// backend.sessions, keyed by token hash so Resolve avoids a database round-trip
|
|
// on the hot path. Reads are RLocked; writes are Locked. Callers commit the
|
|
// corresponding database write before invoking Add or Remove so the cache stays
|
|
// consistent with the persisted state.
|
|
type Cache struct {
|
|
mu sync.RWMutex
|
|
byHash map[string]Session
|
|
ready atomic.Bool
|
|
}
|
|
|
|
// NewCache constructs an empty Cache. It reports Ready() == false until Warm
|
|
// completes successfully.
|
|
func NewCache() *Cache {
|
|
return &Cache{byHash: make(map[string]Session)}
|
|
}
|
|
|
|
// Warm replaces the cache contents with every active session loaded from store.
|
|
// It is intended to run once at process boot before the listener accepts
|
|
// traffic; success flips Ready to true. Re-warming is supported (useful in
|
|
// tests).
|
|
func (c *Cache) Warm(ctx context.Context, store *Store) error {
|
|
sessions, err := store.ListActive(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.byHash = make(map[string]Session, len(sessions))
|
|
for _, s := range sessions {
|
|
c.byHash[s.TokenHash] = s
|
|
}
|
|
c.ready.Store(true)
|
|
return nil
|
|
}
|
|
|
|
// Ready reports whether Warm has completed at least once. The /readyz probe
|
|
// wires through this so the backend only reports ready once sessions are
|
|
// hydrated.
|
|
func (c *Cache) Ready() bool {
|
|
if c == nil {
|
|
return false
|
|
}
|
|
return c.ready.Load()
|
|
}
|
|
|
|
// Size returns the number of cached active sessions, for startup logs and tests.
|
|
func (c *Cache) Size() int {
|
|
if c == nil {
|
|
return 0
|
|
}
|
|
c.mu.RLock()
|
|
defer c.mu.RUnlock()
|
|
return len(c.byHash)
|
|
}
|
|
|
|
// Get returns the session for tokenHash and a presence flag. A miss returns the
|
|
// zero Session and false.
|
|
func (c *Cache) Get(tokenHash string) (Session, bool) {
|
|
if c == nil {
|
|
return Session{}, false
|
|
}
|
|
c.mu.RLock()
|
|
defer c.mu.RUnlock()
|
|
s, ok := c.byHash[tokenHash]
|
|
return s, ok
|
|
}
|
|
|
|
// Add stores s under its token hash. It is safe to call on an existing entry.
|
|
func (c *Cache) Add(s Session) {
|
|
if c == nil {
|
|
return
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.byHash[s.TokenHash] = s
|
|
}
|
|
|
|
// Remove evicts the entry for tokenHash. Removing a missing entry is a no-op.
|
|
func (c *Cache) Remove(tokenHash string) {
|
|
if c == nil {
|
|
return
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
delete(c.byHash, tokenHash)
|
|
}
|
|
|
|
// RemoveByAccount evicts every cached session belonging to accountID. The
|
|
// account-merge flow uses it to drop a retired secondary account's sessions
|
|
// (Stage 11); a linear scan is adequate at the cache's size.
|
|
func (c *Cache) RemoveByAccount(accountID uuid.UUID) {
|
|
if c == nil {
|
|
return
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
for hash, s := range c.byHash {
|
|
if s.AccountID == accountID {
|
|
delete(c.byHash, hash)
|
|
}
|
|
}
|
|
}
|