《游戏服务端编程实践》19.1 服务划分与部署拓扑

// file: ch19/topology/topology.go
// tier: L1
// verify: go test ./ch19/topology/

package topology

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

var (
	ErrEmptyTopology     = errors.New("topology: empty topology")
	ErrEmptyName         = errors.New("topology: empty service name")
	ErrDuplicateService  = errors.New("topology: duplicate service")
	ErrUnknownDependency = errors.New("topology: unknown dependency")
	ErrCycle             = errors.New("topology: dependency cycle")
)

// Kind 区分服务的部署形态：无状态可以随便扩，有状态要绑定分片和存储。
type Kind string

const (
	KindGateway   Kind = "gateway"
	KindStateless Kind = "stateless"
	KindStateful  Kind = "stateful"
	KindDatabase  Kind = "database"
)

// Service 是拓扑里的一个节点。DependsOn 表示“启动和运行都需要对方”，
// 而不是“偶尔调用一次”，否则拓扑会被无关的边连成一团。
type Service struct {
	Name      string
	Kind      Kind
	Zone      string
	DependsOn []string
}

type Topology struct {
	Services []Service
}

// Report 是校验通过后的产物。Order 是依赖优先的启动顺序，
// Warnings 不阻止部署，但需要在评审时逐条确认。
type Report struct {
	Order    []string
	Warnings []string
}

// Validate 检查重复服务、缺失依赖和循环依赖，并给出启动顺序与孤立服务告警。
func Validate(t Topology) (*Report, error) {
	if len(t.Services) == 0 {
		return nil, ErrEmptyTopology
	}

	byName := make(map[string]Service, len(t.Services))
	for _, s := range t.Services {
		name := strings.TrimSpace(s.Name)
		if name == "" {
			return nil, ErrEmptyName
		}
		if _, ok := byName[name]; ok {
			return nil, fmt.Errorf("%w: %s", ErrDuplicateService, name)
		}
		byName[name] = s
	}

	indegree := make(map[string]int, len(byName))
	dependents := make(map[string][]string, len(byName))
	for name, s := range byName {
		for _, dep := range s.DependsOn {
			if _, ok := byName[dep]; !ok {
				return nil, fmt.Errorf("%w: %s -> %s", ErrUnknownDependency, name, dep)
			}
			indegree[name]++
			dependents[dep] = append(dependents[dep], name)
		}
	}

	order, err := topoSort(byName, indegree, dependents)
	if err != nil {
		return nil, err
	}

	report := &Report{Order: order}
	for _, name := range order {
		if len(byName[name].DependsOn) == 0 && len(dependents[name]) == 0 {
			report.Warnings = append(report.Warnings,
				fmt.Sprintf("isolated service: %s", name))
		}
	}
	return report, nil
}

// topoSort 用 Kahn 算法，并始终对候选队列排序，保证同一份拓扑每次得到相同顺序。
func topoSort(byName map[string]Service, indegree map[string]int, dependents map[string][]string) ([]string, error) {
	ready := make([]string, 0, len(byName))
	for name := range byName {
		if indegree[name] == 0 {
			ready = append(ready, name)
		}
	}
	sort.Strings(ready)

	order := make([]string, 0, len(byName))
	for len(ready) > 0 {
		name := ready[0]
		ready = ready[1:]
		order = append(order, name)

		next := append([]string(nil), dependents[name]...)
		sort.Strings(next)
		for _, dep := range next {
			indegree[dep]--
			if indegree[dep] == 0 {
				ready = append(ready, dep)
			}
		}
		sort.Strings(ready)
	}

	if len(order) != len(byName) {
		stuck := make([]string, 0)
		for name := range byName {
			if indegree[name] > 0 {
				stuck = append(stuck, name)
			}
		}
		sort.Strings(stuck)
		return nil, fmt.Errorf("%w: %s", ErrCycle, strings.Join(stuck, ", "))
	}
	return order, nil
}

// Index 把启动顺序转成“名字 -> 下标”，便于部署脚本判断先后。
func (r *Report) Index() map[string]int {
	idx := make(map[string]int, len(r.Order))
	for i, name := range r.Order {
		idx[name] = i
	}
	return idx
}

// HasWarning 用于部署前检查某条告警是否已经被确认。
func (r *Report) HasWarning(substr string) bool {
	for _, w := range r.Warnings {
		if strings.Contains(w, substr) {
			return true
		}
	}
	return false
}

cd .local/checks/gs-practice-lab && gofmt -l ch19/topology && go vet ./ch19/topology/ && go test ./ch19/topology/ -count=1

ok  	gspractice/ch19/topology	0.297s