《游戏服务端架构·平台化与架构治理》9.2 平台团队、产品团队与 SRE

// file: internal/teamtopology/capability.go
// tier: L1
// verify: go test ./internal/teamtopology/
package teamtopology

import (
	"fmt"
	"sort"
)

// TeamType is the role a team plays in the delivery model, not its seniority.
type TeamType string

const (
	Product  TeamType = "product"
	Platform TeamType = "platform"
	SRE      TeamType = "sre"
)

// Team is the minimum topology record. Capabilities are declared separately so
// ownership can be audited without reading a wiki page.
type Team struct {
	Name string
	Type TeamType
}

// CapabilityKind decides which team type may own a capability.
type CapabilityKind string

const (
	GameFeature    CapabilityKind = "game-feature"
	SharedPlatform CapabilityKind = "shared-platform"
	Reliability    CapabilityKind = "reliability"
)

// Capability is one reusable or game-specific ability with a single owner.
type Capability struct {
	Name  string
	Kind  CapabilityKind
	Owner string
}

// Conflict is one topology violation. Subject is a team, capability, or
// "from->to" pair so the report can be diffed across quarters.
type Conflict struct {
	Subject string
	Rule    string
	Detail  string
}

func teamIndex(teams []Team) (map[string]Team, []Conflict) {
	idx := make(map[string]Team, len(teams))
	var out []Conflict
	for _, t := range teams {
		if t.Name == "" {
			out = append(out, Conflict{Subject: "<team>", Rule: "team-without-name",
				Detail: "team name is empty"})
			continue
		}
		if _, exists := idx[t.Name]; exists {
			out = append(out, Conflict{Subject: t.Name, Rule: "duplicate-team",
				Detail: "team declared more than once"})
			continue
		}
		idx[t.Name] = t
	}
	return idx, out
}

func sortConflicts(cs []Conflict) {
	sort.SliceStable(cs, func(i, j int) bool {
		if cs[i].Subject != cs[j].Subject {
			return cs[i].Subject < cs[j].Subject
		}
		if cs[i].Rule != cs[j].Rule {
			return cs[i].Rule < cs[j].Rule
		}
		return cs[i].Detail < cs[j].Detail
	})
}

var expectedOwner = map[CapabilityKind]TeamType{
	GameFeature:    Product,
	SharedPlatform: Platform,
	Reliability:    SRE,
}

func ownerRule(kind CapabilityKind, ownerType TeamType) (string, bool) {
	switch {
	case kind == GameFeature && ownerType == Platform:
		return "platform-owns-game-feature", true
	case kind == GameFeature && ownerType == SRE:
		return "sre-owns-game-feature", true
	case kind == SharedPlatform && ownerType == Product:
		return "product-rebuilds-platform", true
	case kind == SharedPlatform && ownerType == SRE:
		return "sre-owns-platform-capability", true
	case kind == Reliability && ownerType == Product:
		return "product-owns-reliability", true
	case kind == Reliability && ownerType == Platform:
		return "platform-owns-reliability", true
	}
	return "", false
}

// CapabilityAudit checks three things: every capability has one known owner,
// the owner's team type matches the capability class, and no two teams claim
// the same capability name. The last rule catches "each product builds its own
// matchmaking" before it becomes three platforms.
func CapabilityAudit(teams []Team, caps []Capability) []Conflict {
	idx, out := teamIndex(teams)
	seen := make(map[string]bool, len(caps))
	for _, c := range caps {
		subject := c.Name
		if subject == "" {
			subject = "<capability>"
		}
		if seen[c.Name] && c.Name != "" {
			out = append(out, Conflict{Subject: subject, Rule: "duplicate-capability",
				Detail: "capability declared by more than one team"})
			continue
		}
		seen[c.Name] = true

		want, knownKind := expectedOwner[c.Kind]
		if !knownKind {
			out = append(out, Conflict{Subject: subject, Rule: "unknown-capability-kind",
				Detail: fmt.Sprintf("kind %q is not recognized", c.Kind)})
			continue
		}
		owner, ok := idx[c.Owner]
		if c.Owner == "" {
			out = append(out, Conflict{Subject: subject, Rule: "capability-without-owner",
				Detail: "capability has no owning team"})
			continue
		}
		if !ok {
			out = append(out, Conflict{Subject: subject, Rule: "unknown-capability-owner",
				Detail: fmt.Sprintf("owner %q is not a declared team", c.Owner)})
			continue
		}
		if owner.Type == want {
			continue
		}
		if rule, bad := ownerRule(c.Kind, owner.Type); bad {
			out = append(out, Conflict{Subject: subject, Rule: rule,
				Detail: fmt.Sprintf("%s capability owned by %s team", c.Kind, owner.Type)})
		}
	}
	sortConflicts(out)
	return out
}

cd .local/checks/gsarch-lab
go test -count=1 ./internal/teamtopology/
ok  	gsarchlab/internal/teamtopology	0.254s