《互联网产品的服务端架构·内容、社交与实时互动》10.3 推送失败与降级

// file: internal/push/fallback.go
// tier: L1
// verify: go test ./internal/push/

package push

import "fmt"

// Attempt 记录一次已经发生的投递结果。Reason 只用于日志和排障，
// 不参与路由决策。
type Attempt struct {
	Channel Channel
	OK      bool
	Reason  string
}

// Plan 描述一条通知的主渠道和备用渠道。MaxAttempts 包含主渠道那次尝试。
type Plan struct {
	Primary     Channel
	Fallback    Channel
	MaxAttempts int
}

// Next 根据已发生的 attempts 返回下一次应该投递的渠道。
// 返回 false 表示不再重试：要么已经成功，要么尝试次数用完。
func Next(p Plan, attempts []Attempt) (Channel, bool, error) {
	if p.Primary == "" {
		return "", false, fmt.Errorf("push: plan has empty primary channel")
	}
	if p.Fallback == "" {
		return "", false, fmt.Errorf("push: plan has empty fallback channel")
	}
	if p.Primary == p.Fallback {
		return "", false, fmt.Errorf("push: primary and fallback are both %q", p.Primary)
	}
	if p.MaxAttempts <= 0 {
		return "", false, fmt.Errorf("push: MaxAttempts must be positive, got %d", p.MaxAttempts)
	}
	if len(attempts) == 0 {
		return p.Primary, true, nil
	}
	if len(attempts) >= p.MaxAttempts {
		return "", false, nil
	}
	if attempts[len(attempts)-1].OK {
		return "", false, nil
	}
	if len(attempts) == 1 {
		return p.Fallback, true, nil
	}
	return "", false, nil
}

// file: internal/push/fallback_test.go
// tier: L1
// verify: go test ./internal/push/

package push

import "testing"

func TestNextStartsWithPrimary(t *testing.T) {
	p := Plan{Primary: APNs, Fallback: WebPush, MaxAttempts: 2}
	got, ok, err := Next(p, nil)
	if err != nil {
		t.Fatal(err)
	}
	if !ok || got != APNs {
		t.Fatalf("Next(nil) = %q, %v; want apns, true", got, ok)
	}
}

func TestNextFallsBackAfterPrimaryFailure(t *testing.T) {
	p := Plan{Primary: APNs, Fallback: WebPush, MaxAttempts: 2}
	attempts := []Attempt{{Channel: APNs, OK: false, Reason: "BadDeviceToken"}}
	got, ok, err := Next(p, attempts)
	if err != nil {
		t.Fatal(err)
	}
	if !ok || got != WebPush {
		t.Fatalf("Next = %q, %v; want webpush, true", got, ok)
	}
}

func TestNextStopsAfterSuccess(t *testing.T) {
	p := Plan{Primary: APNs, Fallback: WebPush, MaxAttempts: 3}
	attempts := []Attempt{{Channel: APNs, OK: true}}
	got, ok, err := Next(p, attempts)
	if err != nil {
		t.Fatal(err)
	}
	if ok || got != "" {
		t.Fatalf("Next = %q, %v; want no further attempt", got, ok)
	}
}

func TestNextStopsAtMaxAttempts(t *testing.T) {
	p := Plan{Primary: APNs, Fallback: WebPush, MaxAttempts: 2}
	attempts := []Attempt{
		{Channel: APNs, OK: false, Reason: "timeout"},
		{Channel: WebPush, OK: false, Reason: "410 Gone"},
	}
	got, ok, err := Next(p, attempts)
	if err != nil {
		t.Fatal(err)
	}
	if ok || got != "" {
		t.Fatalf("Next = %q, %v; want exhausted", got, ok)
	}

	oneTry := Plan{Primary: APNs, Fallback: WebPush, MaxAttempts: 1}
	got, ok, err = Next(oneTry, attempts[:1])
	if err != nil {
		t.Fatal(err)
	}
	if ok || got != "" {
		t.Fatalf("MaxAttempts=1 Next = %q, %v; want exhausted", got, ok)
	}
}

func TestNextRejectsInvalidPlan(t *testing.T) {
	cases := []Plan{
		{Primary: "", Fallback: WebPush, MaxAttempts: 2},
		{Primary: APNs, Fallback: "", MaxAttempts: 2},
		{Primary: APNs, Fallback: APNs, MaxAttempts: 2},
		{Primary: APNs, Fallback: WebPush, MaxAttempts: 0},
	}
	for _, p := range cases {
		if _, _, err := Next(p, nil); err == nil {
			t.Fatalf("want error for plan %+v", p)
		}
	}
}

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

=== RUN   TestNextStartsWithPrimary
--- PASS: TestNextStartsWithPrimary (0.00s)
=== RUN   TestNextFallsBackAfterPrimaryFailure
--- PASS: TestNextFallsBackAfterPrimaryFailure (0.00s)
=== RUN   TestNextStopsAfterSuccess
--- PASS: TestNextStopsAfterSuccess (0.00s)
=== RUN   TestNextStopsAtMaxAttempts
--- PASS: TestNextStopsAtMaxAttempts (0.00s)
=== RUN   TestNextRejectsInvalidPlan
--- PASS: TestNextRejectsInvalidPlan (0.00s)
PASS
ok  	webapp/internal/push	0.268s