《MMO 服务器开发》11.3 好友关系与关系一致性

// file: internal/chat/friend.go
// tier: L1
// verify: go test ./internal/chat/

package chat

import (
	"errors"
	"sync"
)

// Relation 是好友关系图里一条有向边的状态。
type Relation uint8

const (
	RelNone      Relation = iota
	RelRequested          // From 已向 To 发起申请，等待对方回应
	RelFriend             // 双向好友
	RelBlocked            // From 拉黑了 To
)

func (r Relation) String() string {
	switch r {
	case RelNone:
		return "none"
	case RelRequested:
		return "requested"
	case RelFriend:
		return "friend"
	case RelBlocked:
		return "blocked"
	}
	return "unknown"
}

// FriendService 维护好友关系图。好友是「双向边」，因此所有写操作
// 都必须在同一临界区内成对完成，绝不能只写一半。
type FriendService struct {
	mu      sync.Mutex
	edges   map[PlayerID]map[PlayerID]Relation
	applied map[uint64]FriendResult // 幂等窗口：opID -> 首次结果
}

func NewFriendService() *FriendService {
	return &FriendService{
		edges:   map[PlayerID]map[PlayerID]Relation{},
		applied: map[uint64]FriendResult{},
	}
}

func (s *FriendService) out(a PlayerID) map[PlayerID]Relation {
	m := s.edges[a]
	if m == nil {
		m = map[PlayerID]Relation{}
		s.edges[a] = m
	}
	return m
}

func (s *FriendService) get(a, b PlayerID) Relation { return s.edges[a][b] }

func (s *FriendService) set(a, b PlayerID, r Relation) {
	if r == RelNone {
		if m := s.edges[a]; m != nil {
			delete(m, b)
		}
		return
	}
	s.out(a)[b] = r
}

// FriendOpKind 是关系变更的种类。
type FriendOpKind uint8

const (
	OpRequest FriendOpKind = iota
	OpAccept
	OpRemove
	OpBlock
)

// FriendOp 是一次关系变更请求。ID 是幂等号，客户端重发时复用。
type FriendOp struct {
	ID   uint64
	Kind FriendOpKind
	From PlayerID
	To   PlayerID
}

// FriendResult 是变更结果。Applied=false 表示命中幂等窗口，本次未改动关系图。
type FriendResult struct {
	Applied bool
	State   Relation // 变更后 From 对 To 的关系
}

var (
	ErrSelfOp        = errors.New("friend: cannot operate on self")
	ErrNoRequest     = errors.New("friend: no pending request to accept")
	ErrBlockedByPeer = errors.New("friend: the other side has blocked you")
	ErrBadOp         = errors.New("friend: unknown operation")
)

// Apply 执行一次关系变更。同一个 opID 重复到达时直接返回首次结果，
// 与卷一 11.1 的幂等窗口同一思路：图是共享状态，重复写代价远高于去重。
func (s *FriendService) Apply(op FriendOp) (FriendResult, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if prev, ok := s.applied[op.ID]; ok {
		prev.Applied = false
		return prev, nil
	}
	if op.From == op.To {
		return FriendResult{}, ErrSelfOp
	}
	var err error
	switch op.Kind {
	case OpRequest:
		err = s.request(op.From, op.To)
	case OpAccept:
		err = s.accept(op.From, op.To)
	case OpRemove:
		s.set(op.From, op.To, RelNone)
		s.set(op.To, op.From, RelNone)
	case OpBlock:
		s.set(op.From, op.To, RelBlocked)
		s.set(op.To, op.From, RelNone)
	default:
		return FriendResult{}, ErrBadOp
	}
	if err != nil {
		return FriendResult{}, err
	}
	res := FriendResult{Applied: true, State: s.get(op.From, op.To)}
	s.applied[op.ID] = res
	return res, nil
}

func (s *FriendService) request(a, b PlayerID) error {
	if s.get(b, a) == RelBlocked {
		return ErrBlockedByPeer
	}
	if s.get(a, b) == RelFriend {
		return nil // 已是好友，重复申请是幂等的
	}
	if s.get(b, a) == RelRequested {
		// 双方互相申请，直接成好友：省掉一次「同意」往返。
		s.set(a, b, RelFriend)
		s.set(b, a, RelFriend)
		return nil
	}
	s.set(a, b, RelRequested)
	return nil
}

func (s *FriendService) accept(a, b PlayerID) error {
	if s.get(b, a) != RelRequested {
		return ErrNoRequest
	}
	s.set(a, b, RelFriend)
	s.set(b, a, RelFriend)
	return nil
}

// Friends 返回某玩家的好友列表（升序）。
func (s *FriendService) Friends(a PlayerID) []PlayerID {
	s.mu.Lock()
	defer s.mu.Unlock()
	var out []PlayerID
	for b, r := range s.edges[a] {
		if r == RelFriend {
			out = append(out, b)
		}
	}
	sortIDs(out)
	return out
}

// snippet: internal/chat/friend.go（opID 幂等窗口，节选）

func (s *FriendService) Apply(op FriendOp) (FriendResult, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	// 幂等窗口：命中就直接返回首次结果，不改动关系图。
	if prev, ok := s.applied[op.ID]; ok {
		prev.Applied = false // 标记「本次未生效」，调用方据此决定要不要回包
		return prev, nil
	}
	// ……执行具体变更……
	res := FriendResult{Applied: true, State: s.get(op.From, op.To)}
	s.applied[op.ID] = res // 首次结果落进窗口，后续重发命中它
	return res, nil
}

// file: internal/chat/friend_consistency.go
// tier: L1
// verify: go test ./internal/chat/

package chat

import "sort"

// Check 校验「双向一致」不变量：任何一条 RelFriend 边都必须在两个方向同时存在。
// 返回所有只剩半边的 (from, to) 对，供补偿任务修复。
func (s *FriendService) Check() [][2]PlayerID {
	s.mu.Lock()
	defer s.mu.Unlock()
	var broken [][2]PlayerID
	for a, m := range s.edges {
		for b, r := range m {
			if r == RelFriend && s.get(b, a) != RelFriend {
				broken = append(broken, [2]PlayerID{a, b})
			}
		}
	}
	sort.Slice(broken, func(i, j int) bool {
		if broken[i][0] != broken[j][0] {
			return broken[i][0] < broken[j][0]
		}
		return broken[i][1] < broken[j][1]
	})
	return broken
}

// Repair 把只剩半边的 RelFriend 补齐成双向（以存在的那一边为准），
// 返回修复的边数。离线补偿任务调用它，实现最终一致。
func (s *FriendService) Repair() int {
	s.mu.Lock()
	defer s.mu.Unlock()
	type pair struct{ a, b PlayerID }
	var broken []pair
	for a, m := range s.edges {
		for b, r := range m {
			if r == RelFriend && s.get(b, a) != RelFriend {
				broken = append(broken, pair{a, b})
			}
		}
	}
	for _, p := range broken {
		s.out(p.b)[p.a] = RelFriend
	}
	return len(broken)
}