《后端架构设计·分布式与数据一致性》1.1 从单机到分布式：哪些问题真的变了

reservationID, err := inventory.Reserve(orderID, "sku-a", 2)
if err != nil {
    return fmt.Errorf("place order %s: %w", orderID, err)
}

A(reserve) @1000ms  ──发送──▶  B(confirm) @995ms
按墙上时钟排序：B 在前，A 在后（错误）
按因果排序：    A 在前，B 在后（正确）

// file: internal/platform/simcall/simcall.go
// tier: L1
// verify: go test ./internal/platform/simcall/ -count=1
package simcall

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

// Sentinel errors returned by the simulated inventory node.
var (
	ErrRejected          = errors.New("simcall: inventory rejected")
	ErrInsufficientStock = errors.New("simcall: insufficient stock")
	ErrTimeout           = errors.New("simcall: deadline exceeded")
)

// Outcome is what the caller knows after the call returns.
type Outcome string

const (
	OutcomeApplied    Outcome = "APPLIED"
	OutcomeNotApplied Outcome = "NOT_APPLIED"
	OutcomeUnknown    Outcome = "UNKNOWN"
)

// Fault injects one failure mode into the call path.
type Fault int

const (
	FaultNone Fault = iota
	FaultRejectBeforeApply
	FaultTimeoutAfterApply
)

// Mode selects an in-process call or a simulated cross-node call.
type Mode int

const (
	ModeLocal Mode = iota
	ModeRemote
)

// Inventory is the reservation aggregate.
type Inventory struct {
	stock    map[string]int
	reserved map[string]string // orderID -> reservationID
	seq      int
}

// NewInventory copies the initial stock so the caller keeps ownership.
func NewInventory(stock map[string]int) *Inventory {
	cp := make(map[string]int, len(stock))
	for k, v := range stock {
		cp[k] = v
	}
	return &Inventory{stock: cp, reserved: make(map[string]string)}
}

// Reserve applies the reservation idempotently by order ID.
func (inv *Inventory) Reserve(orderID, sku string, qty int) (string, error) {
	if id, ok := inv.reserved[orderID]; ok {
		return id, nil
	}
	if qty <= 0 {
		return "", fmt.Errorf("reserve %s: %w", orderID, ErrRejected)
	}
	if inv.stock[sku] < qty {
		return "", fmt.Errorf("reserve %s: %w", orderID, ErrInsufficientStock)
	}
	inv.stock[sku] -= qty
	inv.seq++
	id := fmt.Sprintf("rsv-%d", inv.seq)
	inv.reserved[orderID] = id
	return id, nil
}

// Stock reports the remaining quantity for a SKU.
func (inv *Inventory) Stock(sku string) int { return inv.stock[sku] }

// ReservationID returns the stored reservation for an order.
func (inv *Inventory) ReservationID(orderID string) (string, bool) {
	id, ok := inv.reserved[orderID]
	return id, ok
}

// Link is the order node's view of the inventory node.
type Link struct {
	Mode      Mode
	Fault     Fault
	Inventory *Inventory
}

// Reserve returns the outcome visible to the caller. UNKNOWN means the
// request may or may not have taken effect.
func (l *Link) Reserve(orderID, sku string, qty int) (Outcome, string, error) {
	if l.Mode == ModeLocal {
		id, err := l.Inventory.Reserve(orderID, sku, qty)
		if err != nil {
			return OutcomeNotApplied, "", err
		}
		return OutcomeApplied, id, nil
	}
	if l.Fault == FaultRejectBeforeApply {
		return OutcomeNotApplied, "", ErrRejected
	}
	id, err := l.Inventory.Reserve(orderID, sku, qty)
	if err != nil {
		return OutcomeNotApplied, "", err
	}
	if l.Fault == FaultTimeoutAfterApply {
		return OutcomeUnknown, "", ErrTimeout
	}
	return OutcomeApplied, id, nil
}

// Event is an observation stamped by a node's wall clock.
type Event struct {
	Node   string
	Name   string
	WallMS int64
}

// ByWallClock sorts a copy of events by wall-clock timestamps.
func ByWallClock(events []Event) []Event {
	out := append([]Event(nil), events...)
	sort.Slice(out, func(i, j int) bool { return out[i].WallMS < out[j].WallMS })
	return out
}

// file: internal/platform/simcall/simcall_test.go
// tier: L1
// verify: go test ./internal/platform/simcall/ -count=1
package simcall

import (
	"errors"
	"testing"
)

func TestReserveOutcomes(t *testing.T) {
	cases := []struct {
		name        string
		mode        Mode
		fault       Fault
		qty         int
		want        Outcome
		wantErr     error
		wantStock   int
		wantReserve bool
	}{
		{"local success", ModeLocal, FaultNone, 2, OutcomeApplied, nil, 8, true},
		{"remote success", ModeRemote, FaultNone, 2, OutcomeApplied, nil, 8, true},
		{"remote reject before apply", ModeRemote, FaultRejectBeforeApply, 2, OutcomeNotApplied, ErrRejected, 10, false},
		{"remote ack lost after apply", ModeRemote, FaultTimeoutAfterApply, 2, OutcomeUnknown, ErrTimeout, 8, true},
		{"remote out of stock", ModeRemote, FaultNone, 11, OutcomeNotApplied, ErrInsufficientStock, 10, false},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			inv := NewInventory(map[string]int{"sku-a": 10})
			link := &Link{Mode: tc.mode, Fault: tc.fault, Inventory: inv}

			got, _, err := link.Reserve("ord-1", "sku-a", tc.qty)
			if got != tc.want {
				t.Fatalf("outcome = %s, want %s", got, tc.want)
			}
			if tc.wantErr == nil && err != nil {
				t.Fatalf("unexpected error: %v", err)
			}
			if tc.wantErr != nil && !errors.Is(err, tc.wantErr) {
				t.Fatalf("error = %v, want %v", err, tc.wantErr)
			}
			if stock := inv.Stock("sku-a"); stock != tc.wantStock {
				t.Fatalf("stock = %d, want %d", stock, tc.wantStock)
			}
			_, reserved := inv.ReservationID("ord-1")
			if reserved != tc.wantReserve {
				t.Fatalf("reserved = %v, want %v", reserved, tc.wantReserve)
			}
		})
	}
}

func TestRetryAfterUnknownDoesNotDoubleReserve(t *testing.T) {
	inv := NewInventory(map[string]int{"sku-a": 5})

	lost := &Link{Mode: ModeRemote, Fault: FaultTimeoutAfterApply, Inventory: inv}
	out, _, err := lost.Reserve("ord-1", "sku-a", 2)
	if out != OutcomeUnknown || !errors.Is(err, ErrTimeout) {
		t.Fatalf("first call = (%s, %v), want (UNKNOWN, timeout)", out, err)
	}
	if stock := inv.Stock("sku-a"); stock != 3 {
		t.Fatalf("stock after unknown = %d, want 3", stock)
	}

	retry := &Link{Mode: ModeRemote, Inventory: inv}
	out, id, err := retry.Reserve("ord-1", "sku-a", 2)
	if out != OutcomeApplied || err != nil {
		t.Fatalf("retry = (%s, %v), want APPLIED", out, err)
	}
	if stock := inv.Stock("sku-a"); stock != 3 {
		t.Fatalf("stock after retry = %d, want 3 (no double reserve)", stock)
	}
	stored, ok := inv.ReservationID("ord-1")
	if !ok || stored != id {
		t.Fatalf("reservation = %q, want %q", stored, id)
	}
}

func TestWallClockCanInvertCausalOrder(t *testing.T) {
	// A reserves at its local 1000ms; B confirms at its local 995ms because
	// B's clock is 10ms behind. Causality says reserve happened first.
	events := []Event{
		{Node: "A", Name: "reserve", WallMS: 1000},
		{Node: "B", Name: "confirm", WallMS: 995},
	}
	got := ByWallClock(events)
	if got[0].Name != "confirm" {
		t.Fatalf("sorted order = %s first, want confirm (demonstrating inversion)", got[0].Name)
	}
}

=== RUN   TestReserveOutcomes
=== RUN   TestReserveOutcomes/local_success
=== RUN   TestReserveOutcomes/remote_success
=== RUN   TestReserveOutcomes/remote_reject_before_apply
=== RUN   TestReserveOutcomes/remote_ack_lost_after_apply
=== RUN   TestReserveOutcomes/remote_out_of_stock
--- PASS: TestReserveOutcomes (0.00s)
    --- PASS: TestReserveOutcomes/local_success (0.00s)
    --- PASS: TestReserveOutcomes/remote_success (0.00s)
    --- PASS: TestReserveOutcomes/remote_reject_before_apply (0.00s)
    --- PASS: TestReserveOutcomes/remote_ack_lost_after_apply (0.00s)
    --- PASS: TestReserveOutcomes/remote_out_of_stock (0.00s)
=== RUN   TestRetryAfterUnknownDoesNotDoubleReserve
--- PASS: TestRetryAfterUnknownDoesNotDoubleReserve (0.00s)
=== RUN   TestWallClockCanInvertCausalOrder
--- PASS: TestWallClockCanInvertCausalOrder (0.00s)
PASS
ok  	archlab/internal/platform/simcall	0.961s