《后端架构设计·演进与治理》13.1 arch-lab 从模块化单体到两服务

// file: internal/evolve/twoservice.go
// tier: L1
// verify: go test ./internal/evolve/ -count=1 -run TestPlace
//
// Single-goroutine experiment. Production needs a per-order lock or an
// idempotency key with a unique constraint; see the boundary notes.
package evolve

import (
	"errors"
	"fmt"
	"time"
)

type State string

const (
	Created           State = "CREATED"
	InventoryReserved State = "INVENTORY_RESERVED"
	Paid              State = "PAID"
	Fulfilled         State = "FULFILLED"
	Cancelled         State = "CANCELLED"
	Refunded          State = "REFUNDED"
)

var (
	ErrNotFound = errors.New("evolve: not found")
	ErrInjected = errors.New("evolve: injected failure")
	allowed     = map[State][]State{
		Created:           {InventoryReserved, Cancelled},
		InventoryReserved: {Paid, Cancelled},
		Paid:              {Fulfilled, Refunded},
		Fulfilled:         {Refunded},
	}
)

type Order struct {
	ID, SKU          string
	Qty, AmountCents int
	State            State
	UpdatedAt        time.Time
}

type Inventory interface {
	Reserve(orderID, sku string, qty int) error
	Release(orderID string) error
	Commit(orderID string) error
	Held(orderID string) int
	Committed(orderID string) int
	Check() []string
}

type Payments interface {
	Charge(orderID string, cents int) error
	Refund(orderID string) error
	Captured(orderID string) int
}

type Orders struct {
	orders  map[string]*Order
	inv     Inventory
	pay     Payments
	now     func() time.Time
	CrashAt State
}

func NewOrders(inv Inventory, pay Payments, now func() time.Time) *Orders {
	return &Orders{orders: map[string]*Order{}, inv: inv, pay: pay, now: now}
}

type Request struct {
	ID, SKU          string
	Qty, AmountCents int
}

func (o *Orders) snap(id string) *Order {
	if order := o.orders[id]; order != nil {
		cp := *order
		return &cp
	}
	return nil
}

func (o *Orders) move(id string, to State) error {
	order := o.orders[id]
	if order == nil {
		return ErrNotFound
	}
	for _, next := range allowed[order.State] {
		if next == to {
			order.State, order.UpdatedAt = to, o.now()
			return nil
		}
	}
	return fmt.Errorf("evolve: illegal %s -> %s", order.State, to)
}

func (o *Orders) Place(req Request) (*Order, error) {
	if req.ID == "" || req.Qty <= 0 || req.AmountCents <= 0 {
		return nil, fmt.Errorf("evolve: invalid request %q", req.ID)
	}
	if existing := o.orders[req.ID]; existing != nil {
		cp := *existing
		return &cp, nil
	}
	o.orders[req.ID] = &Order{ID: req.ID, SKU: req.SKU, Qty: req.Qty,
		AmountCents: req.AmountCents, State: Created, UpdatedAt: o.now()}
	if err := o.inv.Reserve(req.ID, req.SKU, req.Qty); err != nil {
		o.cancel(req.ID)
		return o.snap(req.ID), err
	}
	if err := o.move(req.ID, InventoryReserved); err != nil {
		return o.snap(req.ID), err
	}
	if o.CrashAt == InventoryReserved {
		return o.snap(req.ID), ErrInjected
	}
	return o.chargeAndFulfil(req.ID)
}

func (o *Orders) chargeAndFulfil(id string) (*Order, error) {
	order := o.snap(id)
	if order == nil {
		return nil, ErrNotFound
	}
	if err := o.pay.Charge(id, order.AmountCents); err != nil {
		o.cancel(id)
		return o.snap(id), err
	}
	if err := o.move(id, Paid); err != nil {
		return o.snap(id), err
	}
	if o.CrashAt == Paid {
		return o.snap(id), ErrInjected
	}
	if err := o.inv.Commit(id); err != nil {
		return o.snap(id), err
	}
	if err := o.move(id, Fulfilled); err != nil {
		return o.snap(id), err
	}
	return o.snap(id), nil
}

func (o *Orders) cancel(id string) {
	_ = o.pay.Refund(id)
	_ = o.inv.Release(id)
	if order := o.orders[id]; order != nil && order.State != Fulfilled {
		order.State, order.UpdatedAt = Cancelled, o.now()
	}
}

func (o *Orders) Resume(id string) (*Order, error) {
	order := o.snap(id)
	if order == nil {
		return nil, ErrNotFound
	}
	switch order.State {
	case InventoryReserved:
		return o.chargeAndFulfil(id)
	case Paid:
		if err := o.inv.Commit(id); err != nil {
			return o.snap(id), err
		}
		if err := o.move(id, Fulfilled); err != nil {
			return o.snap(id), err
		}
		return o.snap(id), nil
	case Created:
		return nil, fmt.Errorf("evolve: %s has no reservation; retry Place", id)
	default:
		return order, nil
	}
}

func (o *Orders) Audit() []string {
	var out []string
	for id, order := range o.orders {
		held, committed, paid := o.inv.Held(id), o.inv.Committed(id), o.pay.Captured(id)
		switch order.State {
		case InventoryReserved:
			if held != order.Qty || paid != 0 {
				out = append(out, id+": reserved order disagrees with stock or capture")
			}
		case Paid, Fulfilled:
			if committed != order.Qty || paid != order.AmountCents {
				out = append(out, id+": paid order lacks committed stock or capture")
			}
		case Cancelled:
			if held != 0 || paid != 0 {
				out = append(out, id+": cancelled order still holds stock or money")
			}
		}
	}
	return append(out, o.inv.Check()...)
}

// file: internal/evolve/twoservice_test.go
// tier: L1
// verify: go test ./internal/evolve/ -count=1 -run TestPlace
func TestPlaceHappyPath(t *testing.T) {
	o, m := fixture(5)
	order := place(t, o, "ord-1", 2)
	if order.State != Fulfilled || m.stock != 3 || m.captured["ord-1"] != 19900 {
		t.Fatalf("state=%s stock=%d captured=%d", order.State, m.stock, m.captured["ord-1"])
	}
	if got := o.Audit(); len(got) != 0 {
		t.Fatalf("audit = %v", got)
	}
}

func TestPlaceCrashResume(t *testing.T) {
	for _, at := range []State{InventoryReserved, Paid} {
		o, m := fixture(5)
		o.CrashAt = at
		order, err := o.Place(Request{ID: "ord-3", SKU: "SKU-1", Qty: 2, AmountCents: 19900})
		if !errors.Is(err, ErrInjected) || order.State != at {
			t.Fatalf("at %s: err=%v state=%v", at, err, order.State)
		}
		resumed, err := o.Resume("ord-3")
		if err != nil || resumed.State != Fulfilled {
			t.Fatalf("at %s: resume err=%v state=%v", at, err, resumed.State)
		}
		if m.stock != 3 || m.captured["ord-3"] != 19900 {
			t.Fatalf("at %s: stock=%d captured=%d", at, m.stock, m.captured["ord-3"])
		}
		if got := o.Audit(); len(got) != 0 {
			t.Fatalf("at %s: audit = %v", at, got)
		}
	}
}

$ gofmt -l .
$ go vet ./...
$ go test ./internal/evolve/ -count=1 -v -run TestPlace
=== RUN   TestPlaceHappyPath
--- PASS: TestPlaceHappyPath (0.00s)
=== RUN   TestPlacePaymentFailureCompensates
--- PASS: TestPlacePaymentFailureCompensates (0.00s)
=== RUN   TestPlaceCrashResume
--- PASS: TestPlaceCrashResume (0.00s)
=== RUN   TestPlaceDuplicateIsIdempotent
--- PASS: TestPlaceDuplicateIsIdempotent (0.00s)
=== RUN   TestAuditDetectsLeak
--- PASS: TestAuditDetectsLeak (0.00s)
PASS
ok  	archlab/internal/evolve	0.267s