615 lines
20 KiB
Go
615 lines
20 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"net/http/pprof"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"git.k6n.net/mats/go-cart-actor/internal/ucp"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/actor"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/cart"
|
|
cartmcp "git.k6n.net/mats/go-cart-actor/pkg/cart/mcp"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/promotions"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/proxy"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/telemetry"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/voucher"
|
|
"git.k6n.net/mats/go-redis-inventory/pkg/inventory"
|
|
"git.k6n.net/mats/platform/catalog"
|
|
"git.k6n.net/mats/platform/config"
|
|
"git.k6n.net/mats/platform/event"
|
|
"git.k6n.net/mats/platform/rabbit"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/prometheus/client_golang/prometheus/promauto"
|
|
"github.com/prometheus/client_golang/prometheus/promhttp"
|
|
amqp "github.com/rabbitmq/amqp091-go"
|
|
"github.com/redis/go-redis/v9"
|
|
"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
|
|
)
|
|
|
|
var (
|
|
grainSpawns = promauto.NewCounter(prometheus.CounterOpts{
|
|
Name: "cart_grain_spawned_total",
|
|
Help: "The total number of spawned grains",
|
|
})
|
|
)
|
|
|
|
func init() {
|
|
os.Mkdir("data", 0755)
|
|
}
|
|
|
|
type App struct {
|
|
pool *actor.SimpleGrainPool[cart.CartGrain]
|
|
server *PoolServer
|
|
}
|
|
|
|
var podIp = os.Getenv("POD_IP")
|
|
var name = os.Getenv("POD_NAME")
|
|
var amqpUrl = os.Getenv("AMQP_URL")
|
|
var redisAddress = os.Getenv("REDIS_ADDRESS")
|
|
var redisPassword = os.Getenv("REDIS_PASSWORD")
|
|
|
|
// normalizeListenAddr accepts either a bare port ("8080") or a full listen
|
|
// address (":8080", "0.0.0.0:8080") and returns a value usable by http.Server.Addr.
|
|
func normalizeListenAddr(v string) string {
|
|
if strings.Contains(v, ":") {
|
|
return v
|
|
}
|
|
return ":" + v
|
|
}
|
|
|
|
// loadUCPCartSigner loads the UCP ECDSA signing key from the path specified in
|
|
// the UCP_SIGNING_KEY_PATH environment variable. Returns nil if unset or unreadable.
|
|
func loadUCPCartSigner() *ucp.SigningConfig {
|
|
path := os.Getenv("UCP_SIGNING_KEY_PATH")
|
|
if path == "" {
|
|
return nil
|
|
}
|
|
pemData, err := os.ReadFile(path)
|
|
if err != nil {
|
|
log.Printf("ucp signing: cannot read key %s: %v", path, err)
|
|
return nil
|
|
}
|
|
cfg, err := ucp.NewSigningConfigFromPEM(pemData, "k6n-ecdsa-2026")
|
|
if err != nil {
|
|
log.Printf("ucp signing: invalid key at %s: %v", path, err)
|
|
return nil
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
func getCountryFromHost(host string) string {
|
|
if strings.Contains(strings.ToLower(host), "-no") {
|
|
return "no"
|
|
}
|
|
if strings.Contains(strings.ToLower(host), "-se") {
|
|
return "se"
|
|
}
|
|
return "se"
|
|
}
|
|
|
|
type MutationContext struct {
|
|
VoucherService voucher.Service
|
|
}
|
|
|
|
type CartChangeEvent struct {
|
|
CartId cart.CartId `json:"cartId"`
|
|
Mutations []actor.ApplyResult `json:"mutations"`
|
|
}
|
|
|
|
func matchesSkuAndLocation(update inventory.InventoryResult, item cart.CartItem) bool {
|
|
if string(update.SKU) == item.Sku {
|
|
if update.LocationID == "se" && item.StoreId == nil {
|
|
return true
|
|
}
|
|
if item.StoreId == nil {
|
|
return false
|
|
}
|
|
if *item.StoreId == string(update.LocationID) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// catalogProjectionCache is the cart's in-process map of SKU → catalog.Projection,
|
|
// updated by reading catalog.projection_published events off the bus. It is the
|
|
// cart-side source of truth for catalog facts (price, tax_class, inventory_tracked
|
|
// flag, currency, image, brand) used at add-to-cart / checkout-reserve decisions.
|
|
// Stock state is NOT cached here — exact qty is still queried synchronously from
|
|
// the inventory service at decision points per docs/inventory-shape.md.
|
|
//
|
|
// Concurrency: read-mostly workload justifies sync.RWMutex.
|
|
//
|
|
// Single-tier storage. The bus is the only writer — the cart does not separately
|
|
// seed from a snapshot file at boot, because the access pattern is point lookup
|
|
// of cart-active SKUs only, and coupling two sources (mmap snapshot + bus-fed
|
|
// map) created duplicated state with subtle drift risk and an mmap-SIGBUS hazard.
|
|
// Cold-grace: the cache may be incomplete for an SKU the cart sees before the
|
|
// first projection_published arrives for it; the cart falls back to the existing
|
|
// PRODUCT_BASE_URL HTTP fetch and overlays the cache fields on top of it.
|
|
//
|
|
// Deletes carry a tombstone in the map (not a plain delete) so a bus delete of
|
|
// an SKU that already fits the cache rules correctly shadows it for Get /
|
|
// IsDeleted lookups — preventing an oversight from re-fetching a deleted SKU
|
|
// before the cache rebuilds. Tombstones have a per-pod lifetime; bus-driven,
|
|
// so the next sweep on the same SKU flips the entry back to live.
|
|
type catalogProjectionCache struct {
|
|
mu sync.RWMutex
|
|
items map[string]projectionEntry
|
|
}
|
|
|
|
// projectionEntry is a cache slot: a live projection, or a tombstone (deleted)
|
|
// that shadows the live fallback.
|
|
type projectionEntry struct {
|
|
proj catalog.Projection
|
|
deleted bool
|
|
}
|
|
|
|
func newCatalogProjectionCache() *catalogProjectionCache {
|
|
return &catalogProjectionCache{items: make(map[string]projectionEntry, 8192)}
|
|
}
|
|
|
|
func (c *catalogProjectionCache) Apply(updates []catalog.ProjectionUpdate) (upserts, deletes int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
for _, u := range updates {
|
|
if u.Deleted {
|
|
c.items[u.SKU] = projectionEntry{deleted: true}
|
|
deletes++
|
|
continue
|
|
}
|
|
if u.SKU == "" {
|
|
continue
|
|
}
|
|
c.items[u.SKU] = projectionEntry{proj: u.Projection}
|
|
upserts++
|
|
}
|
|
return
|
|
}
|
|
|
|
func (c *catalogProjectionCache) Get(sku string) (catalog.Projection, bool) {
|
|
c.mu.RLock()
|
|
e, ok := c.items[sku]
|
|
c.mu.RUnlock()
|
|
if !ok {
|
|
return catalog.Projection{}, false
|
|
}
|
|
if e.deleted {
|
|
return catalog.Projection{}, false
|
|
}
|
|
return e.proj, true
|
|
}
|
|
|
|
// IsDeleted reports whether a tombstone exists for sku — used by HTTP-fetch
|
|
// call sites to skip the fallback for an SKU the bus has explicitly deleted,
|
|
// avoiding a wasteful round-trip on items the writer has just removed.
|
|
func (c *catalogProjectionCache) IsDeleted(sku string) bool {
|
|
c.mu.RLock()
|
|
e, ok := c.items[sku]
|
|
c.mu.RUnlock()
|
|
return ok && e.deleted
|
|
}
|
|
|
|
// Len reports the number of map entries (bus-fed upserts + tombstones). Used
|
|
// for log gauges only.
|
|
func (c *catalogProjectionCache) Len() int {
|
|
c.mu.RLock()
|
|
defer c.mu.RUnlock()
|
|
return len(c.items)
|
|
}
|
|
|
|
// projectionDeliveryHandler is the AMQP delivery handler for
|
|
// `catalog.projection_published` on the `catalog` topic exchange. Decodes the
|
|
// []ProjectionUpdate batch and merges it into cache. Returns nil on a batch
|
|
// that doesn't apply locally so the AMQP delivery is acked; returns an error
|
|
// on a decode failure so the broker knows to redeliver / quarantine.
|
|
//
|
|
// Recovery: any panic in a single event is caught so the goroutine keeps
|
|
// draining the queue; the bus stays live across malformed events.
|
|
func projectionDeliveryHandler(cache *catalogProjectionCache) func(amqp.Delivery) error {
|
|
return func(d amqp.Delivery) (err error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
err = fmt.Errorf("projection handler panic recovered: %v", r)
|
|
}
|
|
}()
|
|
var ev event.Event
|
|
if err := json.Unmarshal(d.Body, &ev); err != nil {
|
|
return fmt.Errorf("decode event envelope: %w", err)
|
|
}
|
|
updates, err := catalog.DecodeUpdates(ev.Payload)
|
|
if err != nil {
|
|
return fmt.Errorf("decode projection updates: %w", err)
|
|
}
|
|
upserts, deletes := cache.Apply(updates)
|
|
log.Printf("cart: catalog projection batch applied: upserts=%d deletes=%d total=%d eventID=%s source=%q",
|
|
upserts, deletes, cache.Len(), ev.ID, ev.Source)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
|
|
// cartPort is the bare HTTP port. It drives both the local listener and the
|
|
// port used to proxy to peer pods, so a cluster must run all pods on the
|
|
// same CART_PORT.
|
|
cartPort := config.EnvString("CART_PORT", "8080")
|
|
if i := strings.LastIndex(cartPort, ":"); i >= 0 {
|
|
cartPort = cartPort[i+1:]
|
|
}
|
|
|
|
controlPlaneConfig := actor.DefaultServerConfig()
|
|
|
|
promotionStore, err := promotions.NewStore("data/promotions.json")
|
|
if err != nil {
|
|
log.Fatalf("Error loading promotions: %v\n", err)
|
|
}
|
|
|
|
log.Printf("loaded %d promotions", len(promotionStore.List()))
|
|
|
|
promotionService := promotions.NewPromotionService(nil)
|
|
|
|
//inventoryPubSub := actor.NewPubSub[inventory.InventoryChange]()
|
|
|
|
rdb := redis.NewClient(&redis.Options{
|
|
Addr: redisAddress,
|
|
Password: redisPassword,
|
|
DB: 0,
|
|
})
|
|
inventoryService, err := inventory.NewRedisInventoryService(rdb)
|
|
if err != nil {
|
|
log.Fatalf("Error creating inventory service: %v\n", err)
|
|
}
|
|
_ = inventoryService
|
|
|
|
inventoryReservationService, err := inventory.NewRedisCartReservationService(rdb)
|
|
if err != nil {
|
|
log.Fatalf("Error creating inventory reservation service: %v\n", err)
|
|
}
|
|
|
|
reg := cart.NewCartMultationRegistry(cart.NewCartMutationContext(inventoryReservationService))
|
|
reg.RegisterProcessor(
|
|
actor.NewMutationProcessor(func(ctx context.Context, g *cart.CartGrain) error {
|
|
_, span := tracer.Start(ctx, "Totals and promotions")
|
|
defer span.End()
|
|
|
|
// Clear bypass flags first
|
|
for _, v := range g.Vouchers {
|
|
if v != nil {
|
|
v.BypassedByPromotions = false
|
|
}
|
|
}
|
|
|
|
g.UpdateTotals()
|
|
promotionCtx := promotions.NewContextFromCart(g, promotions.WithNow(time.Now()))
|
|
results, _ := promotionService.EvaluateAll(promotionStore.Snapshot(), promotionCtx)
|
|
|
|
// Check if any qualified promotion rule has a coupon_code condition matching our vouchers
|
|
hasBypassed := false
|
|
for _, res := range results {
|
|
if res.Applicable {
|
|
promotions.WalkConditions(res.Rule.Conditions, func(c promotions.Condition) bool {
|
|
if bc, ok := c.(promotions.BaseCondition); ok && bc.Type == promotions.CondCouponCode {
|
|
var codes []string
|
|
if s, ok := bc.Value.AsString(); ok {
|
|
codes = append(codes, strings.ToLower(s))
|
|
} else if arr, ok := bc.Value.AsStringSlice(); ok {
|
|
for _, s := range arr {
|
|
codes = append(codes, strings.ToLower(s))
|
|
}
|
|
}
|
|
for _, code := range codes {
|
|
for _, v := range g.Vouchers {
|
|
if v != nil && strings.ToLower(v.Code) == code {
|
|
if !v.BypassedByPromotions {
|
|
v.BypassedByPromotions = true
|
|
hasBypassed = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
|
|
if hasBypassed {
|
|
// Re-evaluate with bypassed vouchers
|
|
g.UpdateTotals()
|
|
promotionCtx = promotions.NewContextFromCart(g, promotions.WithNow(time.Now()))
|
|
results, _ = promotionService.EvaluateAll(promotionStore.Snapshot(), promotionCtx)
|
|
}
|
|
|
|
// ApplyResults applies qualifying actions in priority order and records
|
|
// every effect — both applied discounts and pending "spend X more for ..."
|
|
// nudges with their progress — in g.AppliedPromotions.
|
|
promotionService.ApplyResults(g, results, promotionCtx)
|
|
g.Version++
|
|
return nil
|
|
}),
|
|
)
|
|
|
|
diskStorage := actor.NewDiskStorage[cart.CartGrain](config.EnvString("CART_DIR", "data"), reg)
|
|
poolConfig := actor.GrainPoolConfig[cart.CartGrain]{
|
|
MutationRegistry: reg,
|
|
Storage: diskStorage,
|
|
Spawn: func(ctx context.Context, id uint64) (actor.Grain[cart.CartGrain], error) {
|
|
_, span := tracer.Start(ctx, fmt.Sprintf("Spawn cart id %d", id))
|
|
defer span.End()
|
|
grainSpawns.Inc()
|
|
ret := cart.NewCartGrain(id, time.Now())
|
|
// Set baseline lastChange at spawn; replay may update it to last event timestamp.
|
|
|
|
// inventoryPubSub.Subscribe(ret.HandleInventoryChange)
|
|
err := diskStorage.LoadEvents(ctx, id, ret)
|
|
// if err == nil && inventoryService != nil {
|
|
// refs := make([]*inventory.InventoryReference, 0)
|
|
// for _, item := range ret.Items {
|
|
// refs = append(refs, &inventory.InventoryReference{
|
|
// SKU: inventory.SKU(item.Sku),
|
|
// LocationID: getLocationId(item),
|
|
// })
|
|
// }
|
|
// _, span := tracer.Start(ctx, "update inventory")
|
|
// defer span.End()
|
|
// res, err := inventoryService.GetInventoryBatch(ctx, refs...)
|
|
// if err != nil {
|
|
// log.Printf("unable to update inventory %v", err)
|
|
// } else {
|
|
// for _, update := range res {
|
|
// for _, item := range ret.Items {
|
|
// if matchesSkuAndLocation(update, *item) && update.Quantity != uint32(item.Stock) {
|
|
// // maybe apply an update to give visibility to the cart
|
|
// item.Stock = uint16(update.Quantity)
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
return ret, err
|
|
},
|
|
Destroy: func(grain actor.Grain[cart.CartGrain]) error {
|
|
// cart, err := grain.GetCurrentState()
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
//inventoryPubSub.Unsubscribe(cart.HandleInventoryChange)
|
|
|
|
return nil
|
|
},
|
|
SpawnHost: func(host string) (actor.Host[cart.CartGrain], error) {
|
|
return proxy.NewRemoteHost[cart.CartGrain](host, cartPort)
|
|
},
|
|
TTL: 5 * time.Minute,
|
|
PoolSize: 2 * 65535,
|
|
Hostname: podIp,
|
|
}
|
|
|
|
pool, err := actor.NewSimpleGrainPool(poolConfig)
|
|
if err != nil {
|
|
log.Fatalf("Error creating cart pool: %v\n", err)
|
|
}
|
|
|
|
cartMCP := cartmcp.New(pool)
|
|
|
|
// Stream each applied mutation to the shared "mutations" exchange (routing key
|
|
// mutation.cart) so the backoffice /commerce live feed (and other consumers)
|
|
// see cart activity. Best-effort: if AMQP is unreachable the cart still serves.
|
|
if amqpUrl != "" {
|
|
if conn, derr := rabbit.Dial(amqpUrl, "cart"); derr != nil {
|
|
log.Printf("cart: AMQP connect failed, mutation feed disabled: %v", derr)
|
|
} else {
|
|
listener := actor.NewAmqpListener(conn.Connection(), "cart", actor.MutationSummary)
|
|
listener.DefineTopics()
|
|
pool.AddListener(listener)
|
|
log.Printf("cart: mutation feed enabled (mutation.cart)")
|
|
}
|
|
}
|
|
|
|
// catalog.projection_published consumer (the cart is the canonical
|
|
// consumer of the projection wire per docs/inventory-shape.md; inventory
|
|
// emits level crossings back to finder only, never the reverse). Own
|
|
// connection keeps the cart's mutation-feed lifecycle decoupled from a
|
|
// read-write-consume connection that could grow event handlers later
|
|
// (e.g. promotions reacting to a price drop on a watched SKU).
|
|
projectionCache := newCatalogProjectionCache()
|
|
if amqpUrl != "" {
|
|
if pConn, perr := rabbit.Dial(amqpUrl, "cart-catalog-projection"); perr != nil {
|
|
log.Printf("cart: catalog projection consumer DISABLED (dial failed): %v", perr)
|
|
} else {
|
|
pConn.NotifyOnReconnect(func() {
|
|
ch, err := pConn.Channel()
|
|
if err != nil {
|
|
log.Printf("cart: channel on projection reconnect: %v", err)
|
|
return
|
|
}
|
|
if err := rabbit.ListenToPattern(ch, "catalog", string(event.CatalogProjectionPublished), projectionDeliveryHandler(projectionCache)); err != nil {
|
|
log.Printf("cart: bind catalog.projection_published on reconnect: %v", err)
|
|
_ = ch.Close()
|
|
}
|
|
})
|
|
defer func() { _ = pConn.Close() }()
|
|
log.Printf("cart: catalog projection consumer ENABLED (catalog.projection_published on 'catalog' exchange)")
|
|
}
|
|
}
|
|
|
|
syncedServer := NewPoolServer(pool, fmt.Sprintf("%s, %s", name, podIp), projectionCache) //inventoryService, inventoryReservationService)
|
|
|
|
app := &App{
|
|
pool: pool,
|
|
server: syncedServer,
|
|
}
|
|
|
|
mux := http.NewServeMux()
|
|
debugMux := http.NewServeMux()
|
|
|
|
grpcSrv, err := actor.NewControlServer[cart.CartGrain](controlPlaneConfig, pool)
|
|
if err != nil {
|
|
log.Fatalf("Error starting control plane gRPC server: %v\n", err)
|
|
}
|
|
defer grpcSrv.GracefulStop()
|
|
|
|
// go diskStorage.SaveLoop(10 * time.Second)
|
|
UseDiscovery(pool)
|
|
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
|
|
defer stop()
|
|
|
|
otelShutdown, err := telemetry.SetupOTelSDK(ctx)
|
|
if err != nil {
|
|
log.Fatalf("Unable to start otel %v", err)
|
|
}
|
|
|
|
syncedServer.Serve(mux)
|
|
|
|
// Cart MCP edge: inspect and mutate carts — get_cart, get_cart_items,
|
|
// update_item_quantity, remove_cart_item, clear_cart, apply_voucher, etc.
|
|
// Exposes 11 tools on the same grain pool, mounted at /cart-mcp so it does
|
|
// not conflict with the Promotions MCP at /promotions-mcp.
|
|
mux.Handle("/cart-mcp", cartMCP.Handler())
|
|
mux.Handle("/cart-mcp/", cartMCP.Handler())
|
|
|
|
// UCP REST adapter — Universal Commerce Protocol
|
|
cartUCP := ucp.CartHandler(pool)
|
|
if signer := loadUCPCartSigner(); signer != nil {
|
|
cartUCP = ucp.WithSigning(cartUCP, signer)
|
|
log.Print("ucp signing enabled")
|
|
}
|
|
// StripPrefix is required because the sub-mux (CartHandler) registers
|
|
// routes like "GET /{id}" which expect a relative path; Go's ServeMux
|
|
// passes the full request path (e.g. /ucp/v1/carts/123) without stripping
|
|
// the prefix, so the sub-mux would never match.
|
|
//
|
|
// Only the subtree pattern (/ucp/v1/carts/) is registered, NOT the exact
|
|
// pattern (/ucp/v1/carts), because registering both causes Go's ServeMux
|
|
// to redirect the exact match to the subtree root, and StripPrefix
|
|
// interferes with the redirect target (producing a 307 to "/" instead
|
|
// of "/ucp/v1/carts/"). Consumers should use the trailing-slash variant.
|
|
mux.Handle("/ucp/v1/carts/", http.StripPrefix("/ucp/v1/carts", cartUCP))
|
|
|
|
// Stateless promotion evaluation: POST a (possibly partial) eval context and
|
|
// get back the resulting totals plus the applied/pending effect breakdown,
|
|
// without creating or mutating a real cart.
|
|
mux.HandleFunc("POST /promotions/evaluate", newPromotionEvaluateHandler(promotionStore, promotionService))
|
|
|
|
// only for local
|
|
mux.HandleFunc("GET /add/remote/{host}", func(w http.ResponseWriter, r *http.Request) {
|
|
pool.AddRemote(r.PathValue("host"))
|
|
})
|
|
|
|
debugMux.HandleFunc("/debug/pprof/", pprof.Index)
|
|
debugMux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
|
|
debugMux.HandleFunc("/debug/pprof/profile", pprof.Profile)
|
|
debugMux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
|
|
debugMux.HandleFunc("/debug/pprof/trace", pprof.Trace)
|
|
debugMux.Handle("/metrics", promhttp.Handler())
|
|
|
|
// Projection cache probe (dev/verification). GET /debug/projection/{sku} →
|
|
// the resolved projection + the bus-fed map size. map_entries counts both
|
|
// live projections and tombstones; a found=true response confirms the bus
|
|
// consumer delivered the SKU to this pod.
|
|
debugMux.HandleFunc("/debug/projection/", func(w http.ResponseWriter, r *http.Request) {
|
|
sku := strings.TrimPrefix(r.URL.Path, "/debug/projection/")
|
|
p, found := projectionCache.Get(sku)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_ = json.NewEncoder(w).Encode(map[string]any{
|
|
"sku": sku,
|
|
"found": found,
|
|
"projection": p,
|
|
"map_entries": projectionCache.Len(),
|
|
"deleted": projectionCache.IsDeleted(sku),
|
|
})
|
|
})
|
|
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
|
|
// Grain pool health: simple capacity check (mirrors previous GrainHandler.IsHealthy)
|
|
grainCount, capacity := app.pool.LocalUsage()
|
|
if grainCount >= capacity {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("grain pool at capacity"))
|
|
return
|
|
}
|
|
if !pool.IsHealthy() {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte("control plane not healthy"))
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("ok"))
|
|
})
|
|
mux.HandleFunc("/readyz", func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("ok"))
|
|
})
|
|
mux.HandleFunc("/livez", func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("ok"))
|
|
})
|
|
|
|
mux.HandleFunc("/version", func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("1.0.0"))
|
|
})
|
|
|
|
mux.HandleFunc("/openapi.json", ServeEmbeddedOpenAPI)
|
|
|
|
httpAddr := normalizeListenAddr(cartPort)
|
|
debugAddr := normalizeListenAddr(config.EnvString("CART_DEBUG_PORT", "8081"))
|
|
|
|
srv := &http.Server{
|
|
Addr: httpAddr,
|
|
BaseContext: func(net.Listener) context.Context { return ctx },
|
|
ReadTimeout: 10 * time.Second,
|
|
// Close idle keep-alive connections so a load test with many short-lived
|
|
// clients doesn't pin file handles open indefinitely.
|
|
IdleTimeout: 60 * time.Second,
|
|
WriteTimeout: 20 * time.Second,
|
|
Handler: otelhttp.NewHandler(mux, "/"),
|
|
}
|
|
|
|
defer func() {
|
|
|
|
fmt.Println("Shutting down due to signal")
|
|
otelShutdown(context.Background())
|
|
diskStorage.Close()
|
|
pool.Close()
|
|
|
|
}()
|
|
|
|
srvErr := make(chan error, 1)
|
|
go func() {
|
|
srvErr <- srv.ListenAndServe()
|
|
}()
|
|
|
|
// Inventory change consumption used to live here over the bare Redis
|
|
// `inventory_changed` channel; it is now owned by the cart-inventory
|
|
// service, which translates quantity changes into inventory.level_changed
|
|
// bus crossings. The cart reads exact stock synchronously when it needs it.
|
|
// See docs/inventory-shape.md.
|
|
|
|
log.Printf("Server started at %s (debug %s)", httpAddr, debugAddr)
|
|
|
|
go http.ListenAndServe(debugAddr, debugMux)
|
|
|
|
select {
|
|
case err = <-srvErr:
|
|
// Error when starting HTTP server.
|
|
log.Fatalf("Unable to start server: %v", err)
|
|
case <-ctx.Done():
|
|
// Wait for first CTRL+C.
|
|
// Stop receiving signal notifications as soon as possible.
|
|
stop()
|
|
}
|
|
|
|
}
|