《游戏服务端架构·品类、状态与拓扑》13.1 三款产品的架构基线

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

import (
	"errors"
	"fmt"
	"sort"
)

var (
	ErrMissingField      = errors.New("baseline: required field is empty")
	ErrUnknownProduct    = errors.New("baseline: unknown product")
	ErrDuplicateProduct  = errors.New("baseline: product declared twice")
	ErrDuplicateUnit     = errors.New("baseline: duplicate deploy unit")
	ErrBadState          = errors.New("baseline: state cell needs name, owner and a known persistence")
	ErrBadSLA            = errors.New("baseline: sla needs a name and positive p99 budget")
	ErrBadRisk           = errors.New("baseline: risk needs id, 1..5 severity and trigger")
	ErrTopologyMismatch  = errors.New("baseline: topology differs from the reviewed baseline")
	ErrAuthorityMismatch = errors.New("baseline: authority differs from the reviewed baseline")
	ErrPlatformMismatch  = errors.New("baseline: products disagree on the platform")
	ErrUnitContract      = errors.New("baseline: deploy units violate the product contract")
)

var canonical = map[Product]struct {
	Topology  Topology
	Authority Authority
	Units     []string
}{
	RiftBattle:     {LobbyRoom, PredictionRollback, []string{"lobby", "allocator", "room"}},
	Archipelago:    {GlobalShard, ServerStateSync, []string{"gateway", "world-shard", "economy", "alliance", "global-event"}},
	BubbleWorkshop: {ModularMonolith, ServerAuthoritative, []string{"api"}},
}

func (b Baseline) unit(name string) (DeployUnit, bool) {
	for _, u := range b.Units {
		if u.Name == name {
			return u, true
		}
	}
	return DeployUnit{}, false
}

func (b Baseline) validate() []Issue {
	var out []Issue
	add := func(field, msg string) { out = append(out, Issue{b.Product, field, msg}) }
	if b.Product == "" {
		add("product", ErrMissingField.Error())
	}
	if b.Topology == "" {
		add("topology", ErrMissingField.Error())
	}
	if b.Connection == "" {
		add("connection", ErrMissingField.Error())
	}
	if b.Authority == "" {
		add("authority", ErrMissingField.Error())
	}
	if b.Platform == "" {
		add("platform", ErrMissingField.Error())
	}
	if len(b.State) == 0 {
		add("state", ErrMissingField.Error())
	}
	for i, s := range b.State {
		if s.Name == "" || s.Owner == "" ||
			(s.Persistence != "memory" && s.Persistence != "durable" && s.Persistence != "snapshot") {
			add(fmt.Sprintf("state[%d]", i), ErrBadState.Error())
		}
	}
	if len(b.Units) == 0 {
		add("units", ErrMissingField.Error())
	}
	seen := map[string]bool{}
	for i, u := range b.Units {
		if u.Name == "" || u.FailureScope == "" {
			add(fmt.Sprintf("units[%d]", i), ErrMissingField.Error())
		}
		if seen[u.Name] {
			add(fmt.Sprintf("units[%d]", i), ErrDuplicateUnit.Error())
		}
		seen[u.Name] = true
	}
	if len(b.SLAs) == 0 {
		add("slas", ErrMissingField.Error())
	}
	for i, s := range b.SLAs {
		if s.Name == "" || s.P99MS <= 0 {
			add(fmt.Sprintf("slas[%d]", i), ErrBadSLA.Error())
		}
	}
	if len(b.Risks) == 0 {
		add("risks", ErrMissingField.Error())
	}
	for i, r := range b.Risks {
		if r.ID == "" || r.Severity < 1 || r.Severity > 5 || r.Trigger == "" {
			add(fmt.Sprintf("risks[%d]", i), ErrBadRisk.Error())
		}
	}
	if len(b.Accepted) == 0 {
		add("accepted", ErrMissingField.Error())
	}
	if len(b.ReviewTriggers) == 0 {
		add("review_triggers", ErrMissingField.Error())
	}
	return out
}

// ValidateSet checks each baseline for completeness and then checks the set
// across products: one card per product, same platform, canonical topology and
// authority, and the deploy units each product promised in volume one.
func ValidateSet(bs []Baseline) Report {
	var issues []Issue
	seen := make(map[Product]bool, len(canonical))
	platform := ""
	for _, b := range bs {
		want, known := canonical[b.Product]
		if !known {
			issues = append(issues, Issue{b.Product, "product", ErrUnknownProduct.Error()})
			continue
		}
		if seen[b.Product] {
			issues = append(issues, Issue{b.Product, "product", ErrDuplicateProduct.Error()})
		}
		seen[b.Product] = true
		issues = append(issues, b.validate()...)
		if b.Topology != want.Topology {
			issues = append(issues, Issue{b.Product, "topology",
				fmt.Sprintf("%v: want %s got %s", ErrTopologyMismatch, want.Topology, b.Topology)})
		}
		if b.Authority != want.Authority {
			issues = append(issues, Issue{b.Product, "authority",
				fmt.Sprintf("%v: want %s got %s", ErrAuthorityMismatch, want.Authority, b.Authority)})
		}
		if platform == "" {
			platform = b.Platform
		} else if b.Platform != platform {
			issues = append(issues, Issue{b.Product, "platform", ErrPlatformMismatch.Error()})
		}
		for _, name := range want.Units {
			if _, ok := b.unit(name); !ok {
				issues = append(issues, Issue{b.Product, "units",
					fmt.Sprintf("%v: missing %s", ErrUnitContract, name)})
			}
		}
		if b.Product == RiftBattle {
			if u, ok := b.unit("room"); ok && !u.Stateful {
				issues = append(issues, Issue{b.Product, "units", "room unit must be stateful"})
			}
		}
		if b.Product == BubbleWorkshop {
			if _, ok := b.unit("room"); ok {
				issues = append(issues, Issue{b.Product, "units", "rooms stay inside the monolith at this baseline"})
			}
		}
	}
	for p := range canonical {
		if !seen[p] {
			issues = append(issues, Issue{p, "product", "baseline missing from the set"})
		}
	}
	sort.SliceStable(issues, func(i, j int) bool {
		if issues[i].Product != issues[j].Product {
			return issues[i].Product < issues[j].Product
		}
		if issues[i].Field != issues[j].Field {
			return issues[i].Field < issues[j].Field
		}
		return issues[i].Message < issues[j].Message
	})
	return Report{OK: len(issues) == 0, Issues: issues}
}

$ cd .local/checks/gsarch-lab
$ gofmt -l internal/baseline
$ go vet ./internal/baseline/
$ go test -count=1 ./internal/baseline/
ok  	gsarchlab/internal/baseline	0.239s