《互联网产品的服务端架构·规模化与架构演进》8.2 内部平台的能力边界

// file: internal/pipeline/platform.go
// tier: L1
// verify: go test ./internal/pipeline/

package pipeline

import (
	"fmt"
	"math"
	"strings"
)

// MinSLA 是内部平台愿意托管一项能力的最低可用性承诺。
// 低于它说明“平台托管”只是换了个地方部署，并没有换来更稳的边界。
const MinSLA = 0.99

// Capability 描述平台对外提供的一项能力。
// Owner 是唯一负责的团队，SLA 是该能力承诺的可用性（0.99 表示 99%）。
// 没有 Owner 的条目不是平台能力，只是没人认领的中间件。
type Capability struct {
	Name  string
	Owner string
	SLA   float64
}

// Request 是业务团队的申请：谁要用哪项能力。
type Request struct {
	Team       string
	Capability string
}

// Admit 判断一次能力申请是否被平台接受。
// 接受时返回一句可直接写进审批记录的决定说明；拒绝时 error 说明原因。
//
// 拒绝条件刻意保持“可解释”：
//   - 申请方或能力名为空，无法定位责任主体；
//   - 能力不在清单里，平台不为清单外的东西背书；
//   - 能力没有 Owner，出故障时找不到人；
//   - SLA 缺失、越界或低于 MinSLA，平台无法承诺可用的托底。
func Admit(r Request, caps []Capability) (string, error) {
	team := strings.TrimSpace(r.Team)
	if team == "" {
		return "", fmt.Errorf("pipeline: request has no team")
	}
	name := strings.TrimSpace(r.Capability)
	if name == "" {
		return "", fmt.Errorf("pipeline: request from %q has no capability", team)
	}

	for _, c := range caps {
		if c.Name != name {
			continue
		}
		if strings.TrimSpace(c.Owner) == "" {
			return "", fmt.Errorf("pipeline: capability %q has no owner", name)
		}
		if math.IsNaN(c.SLA) || math.IsInf(c.SLA, 0) {
			return "", fmt.Errorf("pipeline: capability %q has non-finite SLA", name)
		}
		if c.SLA <= 0 || c.SLA > 1 {
			return "", fmt.Errorf("pipeline: capability %q has invalid SLA %v", name, c.SLA)
		}
		if c.SLA < MinSLA {
			return "", fmt.Errorf("pipeline: capability %q SLA %.3f is below platform minimum %.3f",
				name, c.SLA, MinSLA)
		}
		return fmt.Sprintf("admit team=%s capability=%s owner=%s sla=%.3f",
			team, name, c.Owner, c.SLA), nil
	}

	return "", fmt.Errorf("pipeline: capability %q is not offered", name)
}

// file: internal/pipeline/platform_test.go
// tier: L1
// verify: go test ./internal/pipeline/

package pipeline

import (
	"math"
	"strings"
	"testing"
)

func TestAdmitAcceptsOwnedCapability(t *testing.T) {
	caps := []Capability{
		{Name: "log-pipeline", Owner: "observability", SLA: 0.995},
		{Name: "feature-flag", Owner: "release", SLA: 0.99},
	}
	got, err := Admit(Request{Team: "payments", Capability: "log-pipeline"}, caps)
	if err != nil {
		t.Fatalf("admit: %v", err)
	}
	for _, want := range []string{"payments", "log-pipeline", "observability", "0.995"} {
		if !strings.Contains(got, want) {
			t.Fatalf("decision %q does not contain %q", got, want)
		}
	}
}

func TestAdmitRejectsUnknownCapability(t *testing.T) {
	caps := []Capability{{Name: "log-pipeline", Owner: "observability", SLA: 0.995}}
	if _, err := Admit(Request{Team: "payments", Capability: "mysql"}, caps); err == nil {
		t.Fatal("unknown capability: want error")
	}
}

func TestAdmitRejectsMissingOwner(t *testing.T) {
	caps := []Capability{{Name: "cache", Owner: "  ", SLA: 0.999}}
	if _, err := Admit(Request{Team: "feed", Capability: "cache"}, caps); err == nil {
		t.Fatal("missing owner: want error")
	}
}

func TestAdmitRejectsLowOrInvalidSLA(t *testing.T) {
	cases := []struct {
		name string
		sla  float64
	}{
		{"below-min", 0.95},
		{"zero", 0},
		{"above-one", 1.2},
		{"nan", math.NaN()},
		{"inf", math.Inf(1)},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			caps := []Capability{{Name: "queue", Owner: "messaging", SLA: tc.sla}}
			if _, err := Admit(Request{Team: "order", Capability: "queue"}, caps); err == nil {
				t.Fatalf("SLA %v: want error", tc.sla)
			}
		})
	}
}

func TestAdmitRejectsEmptyRequest(t *testing.T) {
	caps := []Capability{{Name: "queue", Owner: "messaging", SLA: 0.99}}
	if _, err := Admit(Request{Capability: "queue"}, caps); err == nil {
		t.Fatal("empty team: want error")
	}
	if _, err := Admit(Request{Team: "order"}, caps); err == nil {
		t.Fatal("empty capability: want error")
	}
}

cd .local/checks/webapp-lab && go test ./internal/pipeline/ -run 'TestAdmit' -count=1 -v

=== RUN   TestAdmitAcceptsOwnedCapability
--- PASS: TestAdmitAcceptsOwnedCapability (0.00s)
=== RUN   TestAdmitRejectsUnknownCapability
--- PASS: TestAdmitRejectsUnknownCapability (0.00s)
=== RUN   TestAdmitRejectsMissingOwner
--- PASS: TestAdmitRejectsMissingOwner (0.00s)
=== RUN   TestAdmitRejectsLowOrInvalidSLA
=== RUN   TestAdmitRejectsLowOrInvalidSLA/below-min
=== RUN   TestAdmitRejectsLowOrInvalidSLA/zero
=== RUN   TestAdmitRejectsLowOrInvalidSLA/above-one
=== RUN   TestAdmitRejectsLowOrInvalidSLA/nan
=== RUN   TestAdmitRejectsLowOrInvalidSLA/inf
--- PASS: TestAdmitRejectsLowOrInvalidSLA (0.00s)
    --- PASS: TestAdmitRejectsLowOrInvalidSLA/below-min (0.00s)
    --- PASS: TestAdmitRejectsLowOrInvalidSLA/zero (0.00s)
    --- PASS: TestAdmitRejectsLowOrInvalidSLA/above-one (0.00s)
    --- PASS: TestAdmitRejectsLowOrInvalidSLA/nan (0.00s)
    --- PASS: TestAdmitRejectsLowOrInvalidSLA/inf (0.00s)
=== RUN   TestAdmitRejectsEmptyRequest
--- PASS: TestAdmitRejectsEmptyRequest (0.00s)
PASS
ok  	webapp/internal/pipeline	0.394s