hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
462 lines
11 KiB
Go
462 lines
11 KiB
Go
package statesync
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
ErrScopeRequired = errors.New("state sync scope is required")
|
|
ErrKeyRequired = errors.New("state sync key is required")
|
|
ErrRecordNotFound = errors.New("state sync record not found")
|
|
ErrStaleVersion = errors.New("state sync version is stale")
|
|
ErrVersionConflict = errors.New("state sync version conflicts with existing record")
|
|
ErrPayloadTooLarge = errors.New("state sync payload is too large")
|
|
ErrPayloadInvalid = errors.New("state sync payload is invalid")
|
|
ErrUnsafeName = errors.New("state sync scope or key contains unsafe character")
|
|
ErrStoreClosed = errors.New("state sync store is closed")
|
|
)
|
|
|
|
type EventType string
|
|
|
|
const (
|
|
EventUpsert EventType = "upsert"
|
|
EventDelete EventType = "delete"
|
|
)
|
|
|
|
type Record struct {
|
|
Scope string `json:"scope"`
|
|
Key string `json:"key"`
|
|
Version int64 `json:"version"`
|
|
OwnerNode string `json:"owner_node,omitempty"`
|
|
Payload json.RawMessage `json:"payload,omitempty"`
|
|
UpdatedAt time.Time `json:"updated_at"`
|
|
ExpiresAt time.Time `json:"expires_at,omitempty"`
|
|
Tombstone bool `json:"tombstone,omitempty"`
|
|
}
|
|
|
|
type Event struct {
|
|
Type EventType `json:"type"`
|
|
Record Record `json:"record"`
|
|
}
|
|
|
|
type Options struct {
|
|
MaxPayloadBytes int
|
|
Now func() time.Time
|
|
}
|
|
|
|
type Store interface {
|
|
Upsert(context.Context, Record) (Record, error)
|
|
Delete(context.Context, string, string, int64) (Record, error)
|
|
Get(context.Context, string, string) (Record, bool, error)
|
|
List(context.Context, string) ([]Record, error)
|
|
Watch(context.Context, string, int) (<-chan Event, error)
|
|
SweepExpired(context.Context) (int, error)
|
|
Snapshot() Snapshot
|
|
Close() error
|
|
}
|
|
|
|
type Snapshot struct {
|
|
Records int `json:"records"`
|
|
Watchers map[string]int `json:"watchers,omitempty"`
|
|
Closed bool `json:"closed"`
|
|
}
|
|
|
|
type Memory struct {
|
|
mu sync.RWMutex
|
|
records map[string]Record
|
|
watchers map[string]map[chan Event]struct{}
|
|
maxPayloadBytes int
|
|
now func() time.Time
|
|
done chan struct{}
|
|
closed bool
|
|
}
|
|
|
|
func NewMemory(options Options) *Memory {
|
|
now := options.Now
|
|
if now == nil {
|
|
now = func() time.Time { return time.Now().UTC() }
|
|
}
|
|
return &Memory{
|
|
records: make(map[string]Record),
|
|
watchers: make(map[string]map[chan Event]struct{}),
|
|
maxPayloadBytes: options.MaxPayloadBytes,
|
|
now: now,
|
|
done: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (m *Memory) Upsert(ctx context.Context, record Record) (Record, error) {
|
|
if err := contextErr(ctx); err != nil {
|
|
return Record{}, err
|
|
}
|
|
if m == nil {
|
|
return Record{}, errors.New("state sync memory store is nil")
|
|
}
|
|
record, err := normalizeRecord(record, m.now().UTC())
|
|
if err != nil {
|
|
return Record{}, err
|
|
}
|
|
if m.maxPayloadBytes > 0 && len(record.Payload) > m.maxPayloadBytes {
|
|
return Record{}, fmt.Errorf("%w: %d > %d", ErrPayloadTooLarge, len(record.Payload), m.maxPayloadBytes)
|
|
}
|
|
|
|
m.mu.Lock()
|
|
if m.closed {
|
|
m.mu.Unlock()
|
|
return Record{}, ErrStoreClosed
|
|
}
|
|
key := recordKey(record.Scope, record.Key)
|
|
if current, ok := m.records[key]; ok {
|
|
switch {
|
|
case current.Version > record.Version:
|
|
m.mu.Unlock()
|
|
return Record{}, fmt.Errorf("%w: current=%d next=%d", ErrStaleVersion, current.Version, record.Version)
|
|
case current.Version == record.Version:
|
|
if sameRecordValue(current, record) {
|
|
m.mu.Unlock()
|
|
return cloneRecord(current), nil
|
|
}
|
|
m.mu.Unlock()
|
|
return Record{}, fmt.Errorf("%w: scope=%s key=%s version=%d", ErrVersionConflict, record.Scope, record.Key, record.Version)
|
|
}
|
|
}
|
|
m.records[key] = cloneRecord(record)
|
|
m.publishLocked(ctx, record.Scope, Event{Type: EventUpsert, Record: record})
|
|
m.mu.Unlock()
|
|
return cloneRecord(record), nil
|
|
}
|
|
|
|
func (m *Memory) Delete(ctx context.Context, scope, key string, version int64) (Record, error) {
|
|
if err := contextErr(ctx); err != nil {
|
|
return Record{}, err
|
|
}
|
|
if m == nil {
|
|
return Record{}, errors.New("state sync memory store is nil")
|
|
}
|
|
scope, key, err := normalizeScopeKey(scope, key)
|
|
if err != nil {
|
|
return Record{}, err
|
|
}
|
|
if version <= 0 {
|
|
version = 1
|
|
}
|
|
now := m.now().UTC()
|
|
deleted := Record{Scope: scope, Key: key, Version: version, UpdatedAt: now, Tombstone: true}
|
|
|
|
m.mu.Lock()
|
|
if m.closed {
|
|
m.mu.Unlock()
|
|
return Record{}, ErrStoreClosed
|
|
}
|
|
recordKey := recordKey(scope, key)
|
|
if current, ok := m.records[recordKey]; ok {
|
|
switch {
|
|
case current.Version > version:
|
|
m.mu.Unlock()
|
|
return Record{}, fmt.Errorf("%w: current=%d next=%d", ErrStaleVersion, current.Version, version)
|
|
case current.Version == version:
|
|
if current.Tombstone {
|
|
m.mu.Unlock()
|
|
return cloneRecord(current), nil
|
|
}
|
|
m.mu.Unlock()
|
|
return Record{}, fmt.Errorf("%w: scope=%s key=%s version=%d", ErrVersionConflict, scope, key, version)
|
|
}
|
|
}
|
|
m.records[recordKey] = deleted
|
|
m.publishLocked(ctx, scope, Event{Type: EventDelete, Record: deleted})
|
|
m.mu.Unlock()
|
|
return cloneRecord(deleted), nil
|
|
}
|
|
|
|
func (m *Memory) Get(ctx context.Context, scope, key string) (Record, bool, error) {
|
|
if err := contextErr(ctx); err != nil {
|
|
return Record{}, false, err
|
|
}
|
|
if m == nil {
|
|
return Record{}, false, nil
|
|
}
|
|
scope, key, err := normalizeScopeKey(scope, key)
|
|
if err != nil {
|
|
return Record{}, false, err
|
|
}
|
|
now := m.now().UTC()
|
|
m.mu.RLock()
|
|
record, ok := m.records[recordKey(scope, key)]
|
|
m.mu.RUnlock()
|
|
if !ok || isExpired(record, now) || record.Tombstone {
|
|
return Record{}, false, nil
|
|
}
|
|
return cloneRecord(record), true, nil
|
|
}
|
|
|
|
func (m *Memory) List(ctx context.Context, scope string) ([]Record, error) {
|
|
if err := contextErr(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if m == nil {
|
|
return nil, nil
|
|
}
|
|
scope, err := normalizeScope(scope)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
now := m.now().UTC()
|
|
prefix := scope + "/"
|
|
var out []Record
|
|
m.mu.RLock()
|
|
for key, record := range m.records {
|
|
if !strings.HasPrefix(key, prefix) || record.Tombstone || isExpired(record, now) {
|
|
continue
|
|
}
|
|
out = append(out, cloneRecord(record))
|
|
}
|
|
m.mu.RUnlock()
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Key < out[j].Key })
|
|
return out, nil
|
|
}
|
|
|
|
func (m *Memory) Watch(ctx context.Context, scope string, buffer int) (<-chan Event, error) {
|
|
if err := contextErr(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
if m == nil {
|
|
return nil, errors.New("state sync memory store is nil")
|
|
}
|
|
scope, err := normalizeScope(scope)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buffer < 0 {
|
|
buffer = 0
|
|
}
|
|
ch := make(chan Event, buffer)
|
|
m.mu.Lock()
|
|
if m.closed {
|
|
m.mu.Unlock()
|
|
close(ch)
|
|
return ch, nil
|
|
}
|
|
if m.watchers[scope] == nil {
|
|
m.watchers[scope] = make(map[chan Event]struct{})
|
|
}
|
|
m.watchers[scope][ch] = struct{}{}
|
|
m.mu.Unlock()
|
|
|
|
go func() {
|
|
select {
|
|
case <-ctx.Done():
|
|
case <-m.done:
|
|
}
|
|
m.mu.Lock()
|
|
if watchers := m.watchers[scope]; watchers != nil {
|
|
if _, ok := watchers[ch]; ok {
|
|
delete(watchers, ch)
|
|
close(ch)
|
|
}
|
|
if len(watchers) == 0 {
|
|
delete(m.watchers, scope)
|
|
}
|
|
}
|
|
m.mu.Unlock()
|
|
}()
|
|
return ch, nil
|
|
}
|
|
|
|
func (m *Memory) SweepExpired(ctx context.Context) (int, error) {
|
|
if err := contextErr(ctx); err != nil {
|
|
return 0, err
|
|
}
|
|
if m == nil {
|
|
return 0, nil
|
|
}
|
|
now := m.now().UTC()
|
|
m.mu.Lock()
|
|
if m.closed {
|
|
m.mu.Unlock()
|
|
return 0, ErrStoreClosed
|
|
}
|
|
removed := 0
|
|
for key, record := range m.records {
|
|
if record.Tombstone || isExpired(record, now) {
|
|
delete(m.records, key)
|
|
removed++
|
|
}
|
|
}
|
|
m.mu.Unlock()
|
|
return removed, nil
|
|
}
|
|
|
|
func (m *Memory) Snapshot() Snapshot {
|
|
if m == nil {
|
|
return Snapshot{}
|
|
}
|
|
m.mu.RLock()
|
|
watchers := make(map[string]int, len(m.watchers))
|
|
for scope, list := range m.watchers {
|
|
watchers[scope] = len(list)
|
|
}
|
|
snapshot := Snapshot{Records: len(m.records), Watchers: watchers, Closed: m.closed}
|
|
m.mu.RUnlock()
|
|
if len(snapshot.Watchers) == 0 {
|
|
snapshot.Watchers = nil
|
|
}
|
|
return snapshot
|
|
}
|
|
|
|
func (m *Memory) Close() error {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
m.mu.Lock()
|
|
if m.closed {
|
|
m.mu.Unlock()
|
|
return nil
|
|
}
|
|
m.closed = true
|
|
close(m.done)
|
|
for scope, watchers := range m.watchers {
|
|
for ch := range watchers {
|
|
close(ch)
|
|
}
|
|
delete(m.watchers, scope)
|
|
}
|
|
m.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
// publishLocked 只做非阻塞发送，调用方必须持有 m.mu 写锁。
|
|
// Watch/Close 也在这把锁内关闭 channel，从根源上消除 send-vs-close 竞争。
|
|
func (m *Memory) publishLocked(ctx context.Context, scope string, event Event) {
|
|
if done := contextDone(ctx); done != nil {
|
|
select {
|
|
case <-done:
|
|
return
|
|
default:
|
|
}
|
|
}
|
|
for ch := range m.watchers[scope] {
|
|
select {
|
|
case ch <- cloneEvent(event):
|
|
default:
|
|
}
|
|
}
|
|
}
|
|
|
|
func normalizeRecord(record Record, now time.Time) (Record, error) {
|
|
scope, key, err := normalizeScopeKey(record.Scope, record.Key)
|
|
if err != nil {
|
|
return Record{}, err
|
|
}
|
|
record.Scope = scope
|
|
record.Key = key
|
|
record.OwnerNode = strings.TrimSpace(record.OwnerNode)
|
|
if record.Version <= 0 {
|
|
record.Version = 1
|
|
}
|
|
if record.UpdatedAt.IsZero() {
|
|
record.UpdatedAt = now.UTC()
|
|
} else {
|
|
record.UpdatedAt = record.UpdatedAt.UTC()
|
|
}
|
|
if !record.ExpiresAt.IsZero() {
|
|
record.ExpiresAt = record.ExpiresAt.UTC()
|
|
}
|
|
if len(record.Payload) > 0 && !json.Valid(record.Payload) {
|
|
return Record{}, ErrPayloadInvalid
|
|
}
|
|
record.Payload = cloneJSON(record.Payload)
|
|
return record, nil
|
|
}
|
|
|
|
func normalizeScopeKey(scope, key string) (string, string, error) {
|
|
scope, err := normalizeScope(scope)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
key = strings.TrimSpace(key)
|
|
if key == "" {
|
|
return "", "", ErrKeyRequired
|
|
}
|
|
if hasUnsafeNameRune(key) {
|
|
return "", "", ErrUnsafeName
|
|
}
|
|
return scope, key, nil
|
|
}
|
|
|
|
func normalizeScope(scope string) (string, error) {
|
|
scope = strings.TrimSpace(scope)
|
|
if scope == "" {
|
|
return "", ErrScopeRequired
|
|
}
|
|
if hasUnsafeNameRune(scope) {
|
|
return "", ErrUnsafeName
|
|
}
|
|
return scope, nil
|
|
}
|
|
|
|
func recordKey(scope, key string) string {
|
|
return scope + "/" + key
|
|
}
|
|
|
|
func isExpired(record Record, now time.Time) bool {
|
|
return !record.ExpiresAt.IsZero() && !record.ExpiresAt.After(now)
|
|
}
|
|
|
|
func sameRecordValue(left, right Record) bool {
|
|
return left.OwnerNode == right.OwnerNode &&
|
|
left.ExpiresAt.Equal(right.ExpiresAt) &&
|
|
left.Tombstone == right.Tombstone &&
|
|
string(left.Payload) == string(right.Payload)
|
|
}
|
|
|
|
func cloneEvent(event Event) Event {
|
|
event.Record = cloneRecord(event.Record)
|
|
return event
|
|
}
|
|
|
|
func cloneRecord(record Record) Record {
|
|
record.Payload = cloneJSON(record.Payload)
|
|
return record
|
|
}
|
|
|
|
func cloneJSON(data json.RawMessage) json.RawMessage {
|
|
if data == nil {
|
|
return nil
|
|
}
|
|
return append(json.RawMessage(nil), data...)
|
|
}
|
|
|
|
func hasUnsafeNameRune(value string) bool {
|
|
for _, r := range value {
|
|
if r == '/' || r == '\\' || r == 0 || r < 0x20 || r == 0x7f {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func contextErr(ctx context.Context) error {
|
|
if ctx == nil {
|
|
return nil
|
|
}
|
|
return ctx.Err()
|
|
}
|
|
|
|
func contextDone(ctx context.Context) <-chan struct{} {
|
|
if ctx == nil {
|
|
return nil
|
|
}
|
|
return ctx.Done()
|
|
}
|