《游戏服务端架构·品类、状态与拓扑》11.1 部署单元怎么切

// file: internal/deploy/deploy.go
// tier: L1
// verify: go test ./internal/deploy/
package deploy

import (
	"fmt"
	"sort"
	"strings"
)

type ScaleMode string

const (
	Stateless   ScaleMode = "stateless"
	Partitioned ScaleMode = "partitioned"
	Singleton   ScaleMode = "singleton"
)

const (
	RuleBlankName        = "blank_name"
	RuleDuplicateUnit    = "duplicate_unit"
	RuleUnknownUnit      = "unknown_unit"
	RuleSelfDependency   = "self_dependency"
	RuleCycle            = "cycle"
	RuleBadScale         = "bad_scale"
	RuleDuplicateState   = "duplicate_state_owner"
	RuleUnreachableState = "unreachable_state"
	RuleSharedLib        = "shared_stateful_library"
	RuleUnknownLibUser   = "unknown_library_user"
)

// Unit is one deployable artifact. Owns and Reads are state keys, not table
// names: a key may be a cache namespace, a partition range or a lease record.
type Unit struct {
	Name      string
	Owner     string
	Scale     ScaleMode
	Owns      []string
	Reads     []string
	DependsOn []string
	Release   string
}

// Library is shared code. Holds lists state keys kept inside the library; a
// library that holds state is a deployable unit in disguise.
type Library struct {
	Name   string
	Holds  []string
	UsedBy []string
}

type Catalog struct {
	Units     []Unit
	Libraries []Library
}

type Issue struct {
	Unit   string
	Rule   string
	Detail string
}

func (i Issue) String() string {
	return fmt.Sprintf("%s: %s: %s", i.Unit, i.Rule, i.Detail)
}

// Validate checks the split as a whole. Every rule answers "can this unit be
// released, scaled or failed on its own?" rather than "is the code tidy?".
func Validate(c Catalog) []Issue {
	var issues []Issue
	byName := make(map[string]*Unit, len(c.Units))
	order := make([]string, 0, len(c.Units))

	for i := range c.Units {
		u := &c.Units[i]
		name := strings.TrimSpace(u.Name)
		if name == "" {
			issues = append(issues, Issue{"<unnamed>", RuleBlankName,
				fmt.Sprintf("unit index %d", i)})
			continue
		}
		if byName[name] != nil {
			issues = append(issues, Issue{name, RuleDuplicateUnit, "duplicate name"})
			continue
		}
		if u.Scale != Stateless && u.Scale != Partitioned && u.Scale != Singleton {
			issues = append(issues, Issue{name, RuleBadScale, string(u.Scale)})
		}
		byName[name] = u
		order = append(order, name)
	}
	sort.Strings(order)

	deps := make(map[string][]string, len(order))
	for _, name := range order {
		seen := make(map[string]bool, len(byName[name].DependsOn))
		for _, raw := range byName[name].DependsOn {
			dep := strings.TrimSpace(raw)
			switch {
			case dep == name:
				issues = append(issues, Issue{name, RuleSelfDependency, dep})
			case byName[dep] == nil:
				issues = append(issues, Issue{name, RuleUnknownUnit, dep})
			case !seen[dep]:
				seen[dep] = true
				deps[name] = append(deps[name], dep)
			}
		}
		sort.Strings(deps[name])
	}
	if cycle := findCycle(order, deps); cycle != nil {
		issues = append(issues, Issue{cycle[0], RuleCycle, strings.Join(cycle, "->")})
	}

	owners := make(map[string][]string)
	for _, name := range order {
		seen := make(map[string]bool, len(byName[name].Owns))
		for _, raw := range byName[name].Owns {
			key := strings.TrimSpace(raw)
			if key == "" || seen[key] {
				continue
			}
			seen[key] = true
			owners[key] = append(owners[key], name)
		}
	}
	keys := make([]string, 0, len(owners))
	for key := range owners {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	for _, key := range keys {
		if len(owners[key]) > 1 {
			sort.Strings(owners[key])
			issues = append(issues, Issue{strings.Join(owners[key], ","), RuleDuplicateState, key})
		}
	}

	for _, name := range order {
		reach := reachable(name, deps)
		seen := make(map[string]bool, len(byName[name].Reads))
		for _, raw := range byName[name].Reads {
			key := strings.TrimSpace(raw)
			if key == "" || seen[key] {
				continue
			}
			seen[key] = true
			ok := false
			for _, owner := range owners[key] {
				if owner == name || reach[owner] {
					ok = true
					break
				}
			}
			if !ok {
				issues = append(issues, Issue{name, RuleUnreachableState, key})
			}
		}
	}

	for _, lib := range c.Libraries {
		users := make(map[string]bool, len(lib.UsedBy))
		for _, raw := range lib.UsedBy {
			user := strings.TrimSpace(raw)
			if user == "" {
				continue
			}
			if byName[user] == nil {
				issues = append(issues, Issue{"library:" + lib.Name, RuleUnknownLibUser, user})
				continue
			}
			users[user] = true
		}
		if len(lib.Holds) == 0 || len(users) < 2 {
			continue
		}
		names := make([]string, 0, len(users))
		for user := range users {
			names = append(names, user)
		}
		sort.Strings(names)
		issues = append(issues, Issue{strings.Join(names, ","), RuleSharedLib, lib.Name})
	}

	sort.Slice(issues, func(i, j int) bool {
		if issues[i].Unit != issues[j].Unit {
			return issues[i].Unit < issues[j].Unit
		}
		if issues[i].Rule != issues[j].Rule {
			return issues[i].Rule < issues[j].Rule
		}
		return issues[i].Detail < issues[j].Detail
	})
	return issues
}

func reachable(start string, deps map[string][]string) map[string]bool {
	seen := make(map[string]bool)
	var walk func(string)
	walk = func(name string) {
		for _, dep := range deps[name] {
			if !seen[dep] {
				seen[dep] = true
				walk(dep)
			}
		}
	}
	walk(start)
	return seen
}

// findCycle returns a closed path such as room->settlement->room. The order
// argument is sorted so the reported cycle does not depend on map iteration.
func findCycle(order []string, deps map[string][]string) []string {
	const white, gray, black = 0, 1, 2
	color := make(map[string]int, len(order))
	var stack, cycle []string

	var dfs func(string) bool
	dfs = func(name string) bool {
		color[name] = gray
		stack = append(stack, name)
		for _, next := range deps[name] {
			switch color[next] {
			case gray:
				for i, node := range stack {
					if node == next {
						cycle = append(cycle, stack[i:]...)
						break
					}
				}
				cycle = append(cycle, next)
				return true
			case white:
				if dfs(next) {
					return true
				}
			}
		}
		stack = stack[:len(stack)-1]
		color[name] = black
		return false
	}

	for _, name := range order {
		if color[name] == white && dfs(name) {
			return cycle
		}
	}
	return nil
}

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