《游戏服务端架构·核心系统与契约》2.1 登录态、票据与续期

// file: internal/loginticket/renew.go
// tier: L1
// verify: go test ./internal/loginticket/

// Package loginticket issues short-lived, single-use login tickets and
// renewable session tokens. Tickets answer "this client just passed login";
// session tokens answer "this connection may keep acting as the account".
package loginticket

import "fmt"

// Verify checks a session token without extending it.
func (i *Issuer) Verify(token string) (Claims, error) {
	c, err := i.parse(token)
	if err != nil {
		return Claims{}, err
	}
	if c.Kind != KindSession {
		return Claims{}, ErrMalformed
	}
	i.mu.Lock()
	defer i.mu.Unlock()
	now := i.cfg.Now()
	if err := i.checkWindow(c, now); err != nil {
		return Claims{}, err
	}
	if until, ok := i.revoked[c.SessionID]; ok && now.Before(until) {
		return Claims{}, ErrRevoked
	}
	return c, nil
}

// Renew slides the idle window but never past AbsoluteAt. expectedVersion
// makes concurrent renewals race-safe: only the first one advances.
func (i *Issuer) Renew(token string, expectedVersion uint64) (string, Claims, error) {
	c, err := i.parse(token)
	if err != nil {
		return "", Claims{}, err
	}
	if c.Kind != KindSession {
		return "", Claims{}, ErrMalformed
	}
	i.mu.Lock()
	defer i.mu.Unlock()
	now := i.cfg.Now()
	if err := i.checkWindow(c, now); err != nil {
		return "", Claims{}, err
	}
	if until, ok := i.revoked[c.SessionID]; ok && now.Before(until) {
		return "", Claims{}, ErrRevoked
	}
	if i.version[c.SessionID] != expectedVersion || c.Version != expectedVersion {
		return "", Claims{}, ErrStale
	}
	next := c
	next.Version = c.Version + 1
	next.IssuedAt = now
	next.NotBefore = now
	next.ExpiresAt = now.Add(i.cfg.IdleTTL)
	if next.ExpiresAt.After(c.AbsoluteAt) {
		next.ExpiresAt = c.AbsoluteAt
	}
	next.JTI = fmt.Sprintf("%s-%d", c.SessionID, next.Version)
	i.version[c.SessionID] = next.Version
	token, err = i.sign(next)
	return token, next, err
}

// Revoke kills one session until its absolute deadline.
func (i *Issuer) Revoke(sessionID string) {
	i.mu.Lock()
	defer i.mu.Unlock()
	until, ok := i.sessions[sessionID]
	if !ok {
		until = i.cfg.Now().Add(i.cfg.AbsoluteTTL)
	}
	i.revoked[sessionID] = until
}

// RevokeAccount implements "log out everywhere" for one account.
func (i *Issuer) RevokeAccount(accountID string) int {
	i.mu.Lock()
	defer i.mu.Unlock()
	n := 0
	for sid, acct := range i.owner {
		if acct != accountID {
			continue
		}
		until, ok := i.sessions[sid]
		if !ok {
			until = i.cfg.Now().Add(i.cfg.AbsoluteTTL)
		}
		i.revoked[sid] = until
		n++
	}
	return n
}

// Sweep drops bookkeeping that can no longer affect a decision.
func (i *Issuer) Sweep() int {
	now := i.cfg.Now()
	i.mu.Lock()
	defer i.mu.Unlock()
	n := 0
	for jti, exp := range i.used {
		if !now.Before(exp) {
			delete(i.used, jti)
			n++
		}
	}
	for sid, until := range i.revoked {
		if !now.Before(until) {
			delete(i.revoked, sid)
			delete(i.sessions, sid)
			delete(i.owner, sid)
			delete(i.version, sid)
			n++
		}
	}
	for sid, abs := range i.sessions {
		if !now.Before(abs) {
			delete(i.sessions, sid)
			delete(i.owner, sid)
			delete(i.version, sid)
			n++
		}
	}
	return n
}

// file: internal/loginticket/renew_test.go
// tier: L1
package loginticket

import (
	"errors"
	"fmt"
	"testing"
	"time"
)

func TestRenew(t *testing.T) {
	tests := []struct {
		name    string
		wantErr error
		run     func(*Issuer, *fakeClock) error
	}{
		{"slides idle window", nil, func(i *Issuer, c *fakeClock) error {
			old, _, _ := i.IssueSession("acc-1", "gw-a")
			c.Advance(25 * time.Minute)
			tok, next, err := i.Renew(old, 0)
			if err != nil {
				return err
			}
			if next.Version != 1 {
				return fmt.Errorf("version = %d, want 1", next.Version)
			}
			c.Advance(25 * time.Minute)
			_, err = i.Verify(tok)
			return err
		}},
		{"stale renewal", ErrStale, func(i *Issuer, c *fakeClock) error {
			old, _, _ := i.IssueSession("acc-1", "gw-a")
			if _, _, err := i.Renew(old, 0); err != nil {
				return err
			}
			_, _, err := i.Renew(old, 0)
			return err
		}},
		{"absolute cap", nil, func(i *Issuer, c *fakeClock) error {
			old, cl, _ := i.IssueSession("acc-1", "gw-a")
			c.Advance(25 * time.Minute)
			tok, _, err := i.Renew(old, 0)
			if err != nil {
				return err
			}
			c.Advance(29 * time.Minute)
			_, next, err := i.Renew(tok, 1)
			if err != nil {
				return err
			}
			if !next.ExpiresAt.Equal(cl.AbsoluteAt) {
				return fmt.Errorf("expiry = %v, want absolute %v", next.ExpiresAt, cl.AbsoluteAt)
			}
			return nil
		}},
		{"revoked cannot renew", ErrRevoked, func(i *Issuer, c *fakeClock) error {
			tok, cl, _ := i.IssueSession("acc-1", "gw-a")
			i.Revoke(cl.SessionID)
			_, _, err := i.Renew(tok, 0)
			return err
		}},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			iss, clk := newTestIssuer(t)
			if err := tc.run(iss, clk); !errors.Is(err, tc.wantErr) {
				t.Fatalf("got %v, want %v", err, tc.wantErr)
			}
		})
	}
}

$ cd .local/checks/gsarch-lab
$ gofmt -l internal/loginticket
$ go vet ./internal/loginticket/...
$ go test -count=1 ./internal/loginticket/...
ok  	gsarchlab/internal/loginticket