《游戏服务端架构·平台化与架构治理》9.3 组织变化如何反映到架构

// file: internal/orgevolution/plan.go
// tier: L1
// verify: go test ./internal/orgevolution/
package orgevolution

import (
	"sort"
)

// ChangeKind is the org move that forces an architecture change.
type ChangeKind string

const (
	Merge       ChangeKind = "merge"
	Split       ChangeKind = "split"
	Outsource   ChangeKind = "outsource"
	Independent ChangeKind = "independent"
)

// StepKind is one unit of transition work. The names are deliberately about
// state, not about meetings: dual-run, data-copy, cutover, exit.
type StepKind string

const (
	StepDualRun  StepKind = "dual-run"
	StepDataCopy StepKind = "data-copy"
	StepCutover  StepKind = "cutover"
	StepBilling  StepKind = "billing-owner"
	StepAccess   StepKind = "access-review"
	StepPipeline StepKind = "pipeline-isolation"
	StepExit     StepKind = "exit"
	StepCleanup  StepKind = "cleanup"
)

// Step is scheduled in relative weeks from the start of the change. Temporary
// steps must carry a removal week; that is what stops a bridge interface from
// becoming permanent.
type Step struct {
	Kind        StepKind
	Week        int
	Owner       string
	Reversible  bool
	Temporary   bool
	RemovalWeek int
}

// Plan is one organization change with its architecture work. ExitedWeek is
// the actual completion week, zero while the change is still open.
type Plan struct {
	ID          string
	Kind        ChangeKind
	From        []string
	To          []string
	CutoverWeek int
	ExitWeek    int
	ExitedWeek  int
	Steps       []Step
	Services    []string
	DataStores  []string
}

// Issue is one plan defect. Subject is the plan ID or a step kind so the
// output can be attached to a ticket without translation.
type Issue struct {
	Subject string
	Rule    string
	Detail  string
}

func sortIssues(is []Issue) {
	sort.SliceStable(is, func(i, j int) bool {
		if is[i].Subject != is[j].Subject {
			return is[i].Subject < is[j].Subject
		}
		if is[i].Rule != is[j].Rule {
			return is[i].Rule < is[j].Rule
		}
		return is[i].Detail < is[j].Detail
	})
}

func hasStep(steps []Step, kind StepKind) bool {
	for _, s := range steps {
		if s.Kind == kind {
			return true
		}
	}
	return false
}

func countStep(steps []Step, kind StepKind) int {
	n := 0
	for _, s := range steps {
		if s.Kind == kind {
			n++
		}
	}
	return n
}

var knownKind = map[ChangeKind]bool{
	Merge: true, Split: true, Outsource: true, Independent: true,
}

// file: internal/orgevolution/validate.go
// tier: L1
// verify: go test ./internal/orgevolution/
package orgevolution

import (
	"fmt"
)

// Validate checks the transition plan as a state machine: there is one
// cutover, a dated exit, no temporary artifact without a removal week, and
// every step has an owner. It also requires the steps that the change kind
// cannot safely skip.
func Validate(p Plan) []Issue {
	subject := p.ID
	if subject == "" {
		subject = "<plan>"
	}
	var out []Issue
	add := func(rule, detail string) {
		out = append(out, Issue{Subject: subject, Rule: rule, Detail: detail})
	}

	if p.ID == "" {
		add("plan-without-id", "plan has no stable identifier")
	}
	if len(p.From) == 0 {
		add("no-source-team", "change names no team on the leaving side")
	}
	if len(p.To) == 0 {
		add("no-target-team", "change names no team on the receiving side")
	}
	if !knownKind[p.Kind] {
		add("unknown-change-kind", fmt.Sprintf("kind %q is not recognized", p.Kind))
	}
	if p.CutoverWeek <= 0 {
		add("invalid-cutover-week", fmt.Sprintf("cutover week=%d, want > 0", p.CutoverWeek))
	}
	switch {
	case p.ExitWeek == 0:
		add("missing-exit-deadline", "transition has no exit week")
	case p.ExitWeek <= p.CutoverWeek:
		add("exit-not-after-cutover", fmt.Sprintf("exit week=%d must be after cutover week=%d",
			p.ExitWeek, p.CutoverWeek))
	case p.ExitWeek-p.CutoverWeek > 26:
		add("transition-too-long", fmt.Sprintf("cutover to exit spans %d weeks; cap is 26",
			p.ExitWeek-p.CutoverWeek))
	}

	for _, s := range p.Steps {
		step := string(s.Kind)
		if s.Owner == "" {
			out = append(out, Issue{Subject: subject + "/" + step, Rule: "step-without-owner",
				Detail: "every transition step needs one accountable team"})
		}
		if s.Temporary {
			switch {
			case s.RemovalWeek == 0:
				out = append(out, Issue{Subject: subject + "/" + step, Rule: "temporary-without-removal",
					Detail: "temporary step has no removal week"})
			case p.ExitWeek > 0 && s.RemovalWeek > p.ExitWeek:
				out = append(out, Issue{Subject: subject + "/" + step, Rule: "temporary-outlives-exit",
					Detail: fmt.Sprintf("removal week=%d is after exit week=%d", s.RemovalWeek, p.ExitWeek)})
			}
		}
		if s.Kind == StepDataCopy && !s.Reversible && p.CutoverWeek > 0 && s.Week < p.CutoverWeek {
			out = append(out, Issue{Subject: subject + "/" + string(s.Kind),
				Rule:   "irreversible-data-copy-before-cutover",
				Detail: "data copy cannot be irreversible before the cutover point"})
		}
		if s.Kind != StepCleanup && p.ExitWeek > 0 && s.Week > p.ExitWeek {
			out = append(out, Issue{Subject: subject + "/" + step, Rule: "step-after-exit",
				Detail: fmt.Sprintf("week=%d is after exit week=%d", s.Week, p.ExitWeek)})
		}
	}

	switch {
	case !hasStep(p.Steps, StepDualRun):
		add("missing-dual-run", "no dual-run period; the old and new paths never overlap")
	case countStep(p.Steps, StepCutover) == 0:
		add("missing-cutover", "no cutover step")
	case countStep(p.Steps, StepCutover) > 1:
		add("duplicate-cutover", "more than one cutover step")
	}
	if !hasStep(p.Steps, StepExit) {
		add("missing-exit-step", "exit deadline has no corresponding step")
	}

	switch p.Kind {
	case Split:
		if !hasStep(p.Steps, StepPipeline) {
			add("missing-pipeline-isolation", "split teams need separate build and release pipelines")
		}
	case Merge:
		if !hasStep(p.Steps, StepBilling) {
			add("missing-billing-owner", "merged services need one billing owner")
		}
	case Outsource:
		if !hasStep(p.Steps, StepAccess) {
			add("missing-access-review", "outsourcing needs an access review before cutover")
		}
		if !hasStep(p.Steps, StepBilling) {
			add("missing-billing-owner", "outsourcing needs a named billing owner")
		}
	case Independent:
		if !hasStep(p.Steps, StepAccess) {
			add("missing-access-review", "independent studio needs its own access boundary")
		}
		if !hasStep(p.Steps, StepBilling) {
			add("missing-billing-owner", "independent studio needs a billing owner")
		}
		if !hasStep(p.Steps, StepPipeline) {
			add("missing-pipeline-isolation", "independent studio needs its own release pipeline")
		}
	}

	sortIssues(out)
	return out
}

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