《游戏服务端架构·平台化与架构治理》9.1 团队边界与服务所有权

// file: internal/teamownership/ownership.go
// tier: L1
// verify: go test ./internal/teamownership/
package teamownership

import (
	"fmt"
	"sort"
)

// TeamKind decides which class of work a team is allowed to own.
type TeamKind string

const (
	KindProduct  TeamKind = "product"
	KindPlatform TeamKind = "platform"
	KindSRE      TeamKind = "sre"
)

// Team is the minimum org record the matrix needs. Headcount is used only for
// the on-call feasibility check, not for performance evaluation.
type Team struct {
	Name      string
	Kind      TeamKind
	Headcount int
}

// Service is one deployable unit with an owner and a data owner. DataException
// records an explicit decision when the two differ; an empty string means no
// decision was made and the split is treated as an accident.
type Service struct {
	Name          string
	Owner         string
	DataOwner     string
	DataException string
	Shared        bool
	Platform      bool
	Criticality   int // 0 = best effort, 1 = important, 2 = player-visible outage
}

// Finding is one rule violation. Subject is a service or team name, never a
// person, so the output can be pasted into a review without blame.
type Finding struct {
	Subject string
	Rule    string
	Detail  string
}

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

func sortFindings(fs []Finding) {
	sort.SliceStable(fs, func(i, j int) bool {
		if fs[i].Subject != fs[j].Subject {
			return fs[i].Subject < fs[j].Subject
		}
		if fs[i].Rule != fs[j].Rule {
			return fs[i].Rule < fs[j].Rule
		}
		return fs[i].Detail < fs[j].Detail
	})
}

// OwnershipMatrix answers four questions for every service: does it have one
// owner, is that owner allowed to own it, does the data follow the service,
// and can the owner sustain on-call. It never fills in a default owner.
func OwnershipMatrix(teams []Team, services []Service) []Finding {
	idx, out := teamIndex(teams)
	seen := make(map[string]bool, len(services))
	for _, s := range services {
		subject := s.Name
		if subject == "" {
			subject = "<service>"
		}
		if seen[s.Name] && s.Name != "" {
			out = append(out, Finding{Subject: subject, Rule: "duplicate-service",
				Detail: "service declared more than once"})
			continue
		}
		seen[s.Name] = true

		if s.Criticality < 0 || s.Criticality > 2 {
			out = append(out, Finding{Subject: subject, Rule: "criticality-out-of-range",
				Detail: fmt.Sprintf("criticality=%d, want 0..2", s.Criticality)})
		}

		owner, ok := idx[s.Owner]
		switch {
		case s.Owner == "":
			out = append(out, Finding{Subject: subject, Rule: "missing-owner",
				Detail: "service has no owning team"})
		case !ok:
			out = append(out, Finding{Subject: subject, Rule: "unknown-owner",
				Detail: fmt.Sprintf("owner %q is not a declared team", s.Owner)})
		default:
			if (s.Shared || s.Platform) && owner.Kind != KindPlatform {
				out = append(out, Finding{Subject: subject, Rule: "shared-service-needs-platform-owner",
					Detail: fmt.Sprintf("shared/platform service owned by %s team", owner.Kind)})
			}
			if !s.Shared && !s.Platform && owner.Kind == KindSRE {
				out = append(out, Finding{Subject: subject, Rule: "sre-owns-product-service",
					Detail: "SRE team owns a game-facing service"})
			}
			if s.Criticality == 2 && owner.Headcount < 4 {
				out = append(out, Finding{Subject: subject, Rule: "critical-team-too-small",
					Detail: fmt.Sprintf("owner %q has %d people; 24x7 on-call needs at least 4",
						owner.Name, owner.Headcount)})
			}
		}

		switch {
		case s.DataOwner == "":
			out = append(out, Finding{Subject: subject, Rule: "data-owner-missing",
				Detail: "no team owns the data"})
		default:
			if _, ok := idx[s.DataOwner]; !ok {
				out = append(out, Finding{Subject: subject, Rule: "unknown-data-owner",
					Detail: fmt.Sprintf("data owner %q is not a declared team", s.DataOwner)})
			} else if s.DataOwner != s.Owner && s.DataException == "" {
				out = append(out, Finding{Subject: subject, Rule: "data-ownership-split-without-decision",
					Detail: fmt.Sprintf("service owner %q and data owner %q differ without a recorded exception",
						s.Owner, s.DataOwner)})
			}
		}
	}
	sortFindings(out)
	return out
}

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