《互联网产品的服务端架构·产品、流量与基础能力》12.2 存储、带宽与机器成本

// file: internal/platform/capacity/storage.go
// tier: L1
// verify: go test ./internal/platform/capacity/

package capacity

import "fmt"

// Growth 描述一个只会长大的存储账本。保留天数与副本数常被漏算，
// 而它们往往比日增量更能决定账单。
type Growth struct {
	CurrentGB     float64
	DailyWriteGB  float64
	RetentionDays int
	Replication   int
}

func (g Growth) validate() error {
	switch {
	case g.CurrentGB < 0:
		return fmt.Errorf("capacity: current storage must not be negative")
	case g.DailyWriteGB < 0:
		return fmt.Errorf("capacity: daily write must not be negative")
	case g.RetentionDays < 0:
		return fmt.Errorf("capacity: retention days must not be negative")
	case g.Replication < 1:
		return fmt.Errorf("capacity: replication must be at least 1")
	}
	return nil
}

// SteadyState 计算写入量与过期删除量相等时的总占用：
// 已有数据 + 日增 × 保留天数 × 副本数。
func SteadyState(g Growth) (float64, error) {
	if err := g.validate(); err != nil {
		return 0, err
	}
	retained := g.DailyWriteGB * float64(g.RetentionDays) * float64(g.Replication)
	return g.CurrentGB + retained, nil
}

// AfterDays 计算 days 天后的总量，含已有数据和期间的全部写入。
func AfterDays(g Growth, days int) (float64, error) {
	if err := g.validate(); err != nil {
		return 0, err
	}
	if days < 0 {
		return 0, fmt.Errorf("capacity: days must not be negative")
	}
	added := g.DailyWriteGB * float64(days) * float64(g.Replication)
	return g.CurrentGB + added, nil
}

// file: internal/platform/capacity/storage_test.go
// tier: L1
// verify: go test ./internal/platform/capacity/

package capacity

import (
	"math"
	"testing"
)

func nearStorage(a, b float64) bool { return math.Abs(a-b) < 1e-6 }

func TestSteadyStateCountsRetentionAndReplication(t *testing.T) {
	got, err := SteadyState(Growth{
		CurrentGB:     500,
		DailyWriteGB:  40,
		RetentionDays: 90,
		Replication:   3,
	})
	if err != nil {
		t.Fatal(err)
	}
	// 500 + 40 × 90 × 3 = 11300 GB。
	if !nearStorage(got, 11_300) {
		t.Fatalf("steady state = %f", got)
	}
}

func TestAfterDaysIncludesExistingData(t *testing.T) {
	g := Growth{CurrentGB: 500, DailyWriteGB: 40, RetentionDays: 90, Replication: 3}
	got, err := AfterDays(g, 30)
	if err != nil {
		t.Fatal(err)
	}
	// 500 + 40 × 30 × 3 = 4100 GB。
	if !nearStorage(got, 4_100) {
		t.Fatalf("after 30 days = %f", got)
	}

	// 零天时应只剩已有数据。
	zero, err := AfterDays(g, 0)
	if err != nil {
		t.Fatal(err)
	}
	if !nearStorage(zero, 500) {
		t.Fatalf("after 0 days = %f", zero)
	}

	// 超过保留天数后仍按写入量线性增长：这里只回答“要留多少盘”，
	// 不负责模拟过期删除，稳态由 SteadyState 回答。
	long, err := AfterDays(g, 180)
	if err != nil {
		t.Fatal(err)
	}
	if !nearStorage(long, 22_100) {
		t.Fatalf("after 180 days = %f", long)
	}
}

func TestStorageRejectsBadInput(t *testing.T) {
	ok := Growth{CurrentGB: 10, DailyWriteGB: 1, RetentionDays: 7, Replication: 2}
	bad := []Growth{
		{CurrentGB: -1, DailyWriteGB: 1, RetentionDays: 7, Replication: 2},
		{CurrentGB: 10, DailyWriteGB: -1, RetentionDays: 7, Replication: 2},
		{CurrentGB: 10, DailyWriteGB: 1, RetentionDays: -1, Replication: 2},
		{CurrentGB: 10, DailyWriteGB: 1, RetentionDays: 7, Replication: 0},
	}
	for i, g := range bad {
		if _, err := SteadyState(g); err == nil {
			t.Fatalf("steady case %d: want error", i)
		}
		if _, err := AfterDays(g, 1); err == nil {
			t.Fatalf("after case %d: want error", i)
		}
	}
	if _, err := AfterDays(ok, -1); err == nil {
		t.Fatal("negative days: want error")
	}
	if _, err := SteadyState(ok); err != nil {
		t.Fatalf("valid input rejected: %v", err)
	}
}

// file: internal/platform/capacity/cost.go
// tier: L1
// verify: go test ./internal/platform/capacity/

package capacity

import "fmt"

// Price 是单价表。云厂商的计费维度很多，这里只保留与架构决策相关的三项。
type Price struct {
	CoreHour   float64 // 每核每小时
	GBMonth    float64 // 每 GB 每月
	GBTransfer float64 // 每 GB 出流量
}

// Usage 是月度用量。机器成本按核数 × 小时数计，而不是按整月包干。
type Usage struct {
	Cores      int
	StorageGB  float64
	TransferGB float64
	Hours      int
}

type Cost struct {
	Compute  float64
	Storage  float64
	Transfer float64
	Total    float64
}

// Monthly 把用量拆成计算、存储、带宽三项，并要求总计与分项一致。
func Monthly(u Usage, p Price) (Cost, error) {
	switch {
	case u.Cores <= 0:
		return Cost{}, fmt.Errorf("capacity: cores must be positive")
	case u.Hours < 1:
		return Cost{}, fmt.Errorf("capacity: hours must be at least 1")
	case u.StorageGB < 0:
		return Cost{}, fmt.Errorf("capacity: storage must not be negative")
	case u.TransferGB < 0:
		return Cost{}, fmt.Errorf("capacity: transfer must not be negative")
	case p.CoreHour < 0 || p.GBMonth < 0 || p.GBTransfer < 0:
		return Cost{}, fmt.Errorf("capacity: prices must not be negative")
	}

	c := Cost{
		Compute:  float64(u.Cores) * float64(u.Hours) * p.CoreHour,
		Storage:  u.StorageGB * p.GBMonth,
		Transfer: u.TransferGB * p.GBTransfer,
	}
	c.Total = c.Compute + c.Storage + c.Transfer
	return c, nil
}

// file: internal/platform/capacity/cost_test.go
// tier: L1
// verify: go test ./internal/platform/capacity/

package capacity

import (
	"math"
	"testing"
)

func nearCost(a, b float64) bool { return math.Abs(a-b) < 1e-9 }

func TestMonthlySplitsComputeStorageTransfer(t *testing.T) {
	got, err := Monthly(Usage{
		Cores:      8,
		StorageGB:  2_000,
		TransferGB: 1_500,
		Hours:      730,
	}, Price{
		CoreHour:   0.05,
		GBMonth:    0.02,
		GBTransfer: 0.08,
	})
	if err != nil {
		t.Fatal(err)
	}
	// 计算 8 × 730 × 0.05 = 292；存储 2000 × 0.02 = 40；
	// 带宽 1500 × 0.08 = 120；合计 452。
	if !nearCost(got.Compute, 292) {
		t.Fatalf("compute = %f", got.Compute)
	}
	if !nearCost(got.Storage, 40) {
		t.Fatalf("storage = %f", got.Storage)
	}
	if !nearCost(got.Transfer, 120) {
		t.Fatalf("transfer = %f", got.Transfer)
	}
	if !nearCost(got.Total, 452) {
		t.Fatalf("total = %f", got.Total)
	}
	if math.Abs(got.Total-(got.Compute+got.Storage+got.Transfer)) > 0.01 {
		t.Fatalf("total %.6f does not match parts", got.Total)
	}
}

func TestMonthlyBandwidthDominatesMediaProduct(t *testing.T) {
	// 图片产品的带宽账单超过计算账单：这是案例假设值，不是实测。
	got, err := Monthly(Usage{
		Cores:      4,
		StorageGB:  500,
		TransferGB: 80_000,
		Hours:      730,
	}, Price{
		CoreHour:   0.05,
		GBMonth:    0.02,
		GBTransfer: 0.06,
	})
	if err != nil {
		t.Fatal(err)
	}
	if got.Transfer <= got.Compute {
		t.Fatalf("transfer %.2f should dominate compute %.2f", got.Transfer, got.Compute)
	}
	if !nearCost(got.Total, got.Compute+got.Storage+got.Transfer) {
		t.Fatalf("total = %f", got.Total)
	}
}

func TestMonthlyRejectsBadUsage(t *testing.T) {
	okPrice := Price{CoreHour: 0.05, GBMonth: 0.02, GBTransfer: 0.08}
	bad := []Usage{
		{Cores: 0, StorageGB: 1, TransferGB: 1, Hours: 730},
		{Cores: 2, StorageGB: 1, TransferGB: 1, Hours: 0},
		{Cores: 2, StorageGB: -1, TransferGB: 1, Hours: 730},
		{Cores: 2, StorageGB: 1, TransferGB: -1, Hours: 730},
	}
	for i, u := range bad {
		if _, err := Monthly(u, okPrice); err == nil {
			t.Fatalf("case %d: want error", i)
		}
	}
	badPrices := []Price{
		{CoreHour: -1, GBMonth: 0.02, GBTransfer: 0.08},
		{CoreHour: 0.05, GBMonth: -1, GBTransfer: 0.08},
		{CoreHour: 0.05, GBMonth: 0.02, GBTransfer: -1},
	}
	for i, p := range badPrices {
		if _, err := Monthly(Usage{Cores: 1, Hours: 1}, p); err == nil {
			t.Fatalf("price case %d: want error", i)
		}
	}
	if _, err := Monthly(Usage{Cores: 1, Hours: 1}, okPrice); err != nil {
		t.Fatalf("valid input rejected: %v", err)
	}
}

cd .local/checks/webapp-lab
go test ./internal/platform/capacity/ -run 'TestSteadyState|TestAfterDays|TestStorage|TestMonthly' -v -count=1

=== RUN   TestMonthlySplitsComputeStorageTransfer
--- PASS: TestMonthlySplitsComputeStorageTransfer (0.00s)
=== RUN   TestMonthlyBandwidthDominatesMediaProduct
--- PASS: TestMonthlyBandwidthDominatesMediaProduct (0.00s)
=== RUN   TestMonthlyRejectsBadUsage
--- PASS: TestMonthlyRejectsBadUsage (0.00s)
=== RUN   TestSteadyStateCountsRetentionAndReplication
--- PASS: TestSteadyStateCountsRetentionAndReplication (0.00s)
=== RUN   TestAfterDaysIncludesExistingData
--- PASS: TestAfterDaysIncludesExistingData (0.00s)
=== RUN   TestStorageRejectsBadInput
--- PASS: TestStorageRejectsBadInput (0.00s)
PASS
ok  	webapp/internal/platform/capacity	0.221s