Put it into practice.

// Package orderdesk is the runnable companion to the "Putting it into
// practice" tutorial.
//
// Run it from the module root with:
//
//	goer run ./examples/orderdesk
//
// It models a small order lifecycle: an order actor reserves stock, authorizes
// payment, asks fulfillment to ship the order, and sends a notification. The
// deliberately slow warehouse port gives the dashboard a real parked VM
// continuation to inspect. The inventory actor is supervised and is crashed
// once on purpose so its restart is visible in the output.
package orderdesk

import (
	"fmt"
	"time"

	"goer"
	"goer/imgo"
	"goer/msg"
)

// Main wires the example into the runtime. The CLI owns the outer lifecycle;
// this function only creates the processes and their native effect boundary.
func Main(sys *goer.System) error {
	orderBehaviour, _, err := imgo.Executor(GoerModule, "Order", []msg.Field{
		msg.Str("Status", "idle"),
	})
	if err != nil {
		return err
	}
	inventoryBehaviour, inventoryInit, err := imgo.Executor(GoerModule, "Inventory", nil)
	if err != nil {
		return err
	}
	v2Behaviour, _, err := imgo.Executor(GoerModule, "OrderV2", nil)
	if err != nil {
		return err
	}
	migrateOrder, err := imgo.Migration(GoerModule, "MigrateOrder")
	if err != nil {
		return err
	}

	sys.RegisterPort("notifications", func(req msg.Spec) msg.Spec {
		of, hasAvail := req.Get("Available")
		orderID, _ := req.Get("OrderID")
		mf, _ := req.Get("Message")
		if hasAvail {
			fmt.Printf("notification port: order %v: %v (%v available)\n", orderID.S, mf.S, of.I)
		} else {
			fmt.Printf("notification port: order %v: %v\n", orderID.S, mf.S)
		}
		return msg.Spec{Type: "Notified"}
	})
	sys.RegisterPort("payments", func(req msg.Spec) msg.Spec {
		af, _ := req.Get("AmountCents")
		of, _ := req.Get("OrderID")
		approved := af.I <= 5000
		fmt.Printf("payment port: order %v approved=%t\n", of.S, approved)
		return msg.Spec{Type: "PaymentResult", Fields: []msg.Field{
			msg.Bool("Approved", approved),
			msg.Str("AuthCode", "auth-demo"),
		}}
	})
	sys.RegisterPort("fulfillment", func(req msg.Spec) msg.Spec {
		of, _ := req.Get("OrderID")
		sf, _ := req.Get("SKU")
		qf, _ := req.Get("Quantity")
		fmt.Printf("fulfillment port: order %v queued for %v × %v\n", of.S, sf.S, qf.I)
		return msg.Spec{Type: "FulfillmentQueued"}
	})
	sys.RegisterPort("warehouse", func(req msg.Spec) msg.Spec {
		// This simulates a remote inventory service. While it waits, the order
		// process is parked in Ask and its VM continuation is inspectable.
		time.Sleep(5 * time.Second)
		sf, _ := req.Get("SKU")
		return msg.Spec{Type: "InventoryResult", Fields: []msg.Field{
			msg.Str("SKU", sf.S),
			msg.Int("Available", 12),
		}}
	})

	inventory := sys.Spawn(
		"inventory",
		goer.Init(inventoryInit),
		goer.Behavior(inventoryBehaviour),
		goer.RestartOnCrash,
	)
	v3Behaviour, v3Init, err := imgo.Executor(GoerModule, "OrderV3", []msg.Field{
		msg.Int("Inventory", int64(inventory.Pid())),
		msg.Str("Status", "idle"),
		msg.Int("PriceCents", 499),
	})
	if err != nil {
		return err
	}
	_, orderInit, err := imgo.Executor(GoerModule, "Order", []msg.Field{
		msg.Int("Inventory", int64(inventory.Pid())),
		msg.Str("Status", "idle"),
	})
	if err != nil {
		return err
	}
	orders := sys.Spawn(
		"orders",
		goer.Init(orderInit),
		goer.Behavior(orderBehaviour),
		goer.RestartOnCrash,
	)

	if err := orders.Tell(&msg.Spec{Type: "PlaceOrder", Fields: []msg.Field{
		msg.Str("OrderID", "order-1001"),
		msg.Str("SKU", "coffee-beans"),
		msg.Int("Quantity", 1),
		msg.Int("AmountCents", 499),
	}}); err != nil {
		return err
	}
	go func() {
		timer := time.NewTimer(750 * time.Millisecond)
		defer timer.Stop()
		<-timer.C
		_ = orders.Tell(&msg.Spec{Type: "InspectInventory", Fields: []msg.Field{
			msg.Str("OrderID", "order-1001"),
			msg.Str("SKU", "coffee-beans"),
		}})
		fmt.Println("warehouse check started; inspect the parked orders process in the dashboard")
	}()

	go func() {
		timer := time.NewTimer(2 * time.Second)
		defer timer.Stop()
		<-timer.C
		_ = inventory.Tell(&msg.Spec{Type: "CrashInventory"})
		deadline := time.Now().Add(time.Second)
		for sys.Restarts() == 0 && time.Now().Before(deadline) {
			time.Sleep(10 * time.Millisecond)
		}
		fmt.Printf("inventory crash requested; supervised restarts: %d\n", sys.Restarts())
	}()

	go func() {
		timer := time.NewTimer(4 * time.Second)
		defer timer.Stop()
		<-timer.C
		if err := sys.HotSwap("orders", goer.Behavior(v2Behaviour)); err != nil {
			fmt.Printf("live pricing update failed: %v\n", err)
			return
		}
		fmt.Println("live pricing update applied at a safe point")
		_ = orders.Tell(&msg.Spec{Type: "PlaceOrder", Fields: []msg.Field{
			msg.Str("OrderID", "order-1002"),
			msg.Str("SKU", "tea"),
			msg.Int("Quantity", 1),
			msg.Int("AmountCents", 799),
		}})
	}()

	go func() {
		timer := time.NewTimer(6 * time.Second)
		defer timer.Stop()
		<-timer.C
		if err := sys.Migrate(
			"orders",
			goer.Behavior(v3Behaviour),
			goer.Init(v3Init),
			goer.Migrate(migrateOrder),
		); err != nil {
			fmt.Printf("state migration failed: %v\n", err)
			return
		}
		fmt.Println("order state migrated: added live price without stopping orders")
	}()

	// Keep the dashboard useful after the scripted demonstrations finish. This
	// is deliberately slow: one new order every eight seconds is enough to
	// watch mailboxes, handler timing, ports, and supervision without flooding
	// a terminal or hiding the important events.
	go func() {
		ticker := time.NewTicker(8 * time.Second)
		defer ticker.Stop()
		sequence := 1003
		for range ticker.C {
			orderID := fmt.Sprintf("order-%d", sequence)
			if err := orders.Tell(&msg.Spec{Type: "PlaceOrder", Fields: []msg.Field{
				msg.Str("OrderID", orderID),
				msg.Str("SKU", "coffee-beans"),
				msg.Int("Quantity", 1),
				msg.Int("AmountCents", 499),
			}}); err != nil {
				fmt.Printf("order intake: %s rejected: %v\n", orderID, err)
				continue
			}
			fmt.Printf("order intake: received %s\n", orderID)
			sequence++
		}
	}()

	go func() {
		ticker := time.NewTicker(12 * time.Second)
		defer ticker.Stop()
		for range ticker.C {
			_ = inventory.Tell(&msg.Spec{Type: "Restock", Fields: []msg.Field{
				msg.Int("Quantity", 4),
			}})
			fmt.Println("inventory intake: restocked 4 units")
		}
	}()

	return nil
}

//go:build goer && goer_source

package orderdesk

import . "goer"

type OrderState struct {
	Inventory   Pid
	Status      string
	OrderID     string
	SKU         string
	Quantity    int
	AmountCents int
}

type InventoryState struct {
	Stock int
}

type PlaceOrder struct {
	OrderID     string
	SKU         string
	Quantity    int
	AmountCents int
}

type ReserveStock struct {
	OrderID  string
	SKU      string
	Quantity int
	ReplyTo  Pid
}

type StockReserved struct {
	OrderID  string
	SKU      string
	Quantity int
}

type AuthorizePayment struct {
	OrderID     string
	AmountCents int
}

type PaymentResult struct {
	Approved bool
	AuthCode string
}

type FulfillOrder struct {
	OrderID  string
	SKU      string
	Quantity int
}

type InspectInventory struct {
	OrderID string
	SKU     string
}

type InventoryRequest struct {
	SKU string
}

type InventoryResult struct {
	SKU       string
	Available int
}

type CrashInventory struct{}

type Restock struct {
	Quantity int
}

type Notify struct {
	OrderID   string
	Message   string
	Available int
}

type Msg interface{}

func OrderInit() OrderState { return OrderState{Status: "idle"} }

func InventoryInit() InventoryState { return InventoryState{Stock: 4} }

func Order(s OrderState, m Msg) OrderState {
	switch x := m.(type) {
	case PlaceOrder:
		s.OrderID = x.OrderID
		s.SKU = x.SKU
		s.Quantity = x.Quantity
		s.AmountCents = x.AmountCents
		s.Status = "waiting for stock"
		s.Inventory <- ReserveStock{OrderID: x.OrderID, SKU: x.SKU, Quantity: x.Quantity, ReplyTo: Self()}
	case StockReserved:
		s.Status = "authorizing payment"
		payment := Ask(Port("payments"), AuthorizePayment{OrderID: s.OrderID, AmountCents: s.AmountCents}).(PaymentResult)
		if payment.Approved {
			s.Status = "fulfilling"
			Port("fulfillment") <- FulfillOrder{OrderID: s.OrderID, SKU: s.SKU, Quantity: s.Quantity}
			Port("notifications") <- Notify{OrderID: s.OrderID, Message: "order confirmed"}
		} else {
			s.Status = "payment declined"
			Port("notifications") <- Notify{OrderID: s.OrderID, Message: "payment declined"}
		}
	case InspectInventory:
		result := Ask(Port("warehouse"), InventoryRequest{SKU: x.SKU}).(InventoryResult)
		s.OrderID = x.OrderID
		if result.Available > 0 {
			s.Status = "warehouse checked"
		} else {
			s.Status = "out of stock"
		}
		Port("notifications") <- Notify{OrderID: x.OrderID, Message: "warehouse check complete", Available: result.Available}
	}
	return s
}

func Inventory(s InventoryState, m Msg) InventoryState {
	switch x := m.(type) {
	case ReserveStock:
		if s.Stock < x.Quantity {
			panic("not enough stock")
		}
		s.Stock = s.Stock - x.Quantity
		x.ReplyTo <- StockReserved{OrderID: x.OrderID, SKU: x.SKU, Quantity: x.Quantity}
	case CrashInventory:
		panic("inventory restart requested")
	case Restock:
		s.Stock = s.Stock + x.Quantity
	}
	return s
}

//go:build goer && goer_source

package orderdesk

func OrderV2Init() OrderState { return OrderState{Status: "idle"} }

func OrderV2(s OrderState, m Msg) OrderState {
	switch x := m.(type) {
	case PlaceOrder:
		s.OrderID = x.OrderID
		s.SKU = x.SKU
		s.Quantity = x.Quantity
		s.AmountCents = x.AmountCents
		s.Status = "waiting for stock"
		s.Inventory <- ReserveStock{OrderID: x.OrderID, SKU: x.SKU, Quantity: x.Quantity, ReplyTo: Self()}
	case StockReserved:
		s.Status = "authorizing payment"
		payment := Ask(Port("payments"), AuthorizePayment{OrderID: s.OrderID, AmountCents: s.AmountCents}).(PaymentResult)
		if payment.Approved {
			s.Status = "fulfilling"
			Port("fulfillment") <- FulfillOrder{OrderID: s.OrderID, SKU: s.SKU, Quantity: s.Quantity}
			Port("notifications") <- Notify{OrderID: s.OrderID, Message: "order confirmed with live pricing"}
		}
	}
	return s
}

//go:build goer && goer_source

package orderdesk

type OrderStateV3 struct {
	Inventory   Pid
	Status      string
	OrderID     string
	SKU         string
	Quantity    int
	AmountCents int
	PriceCents  int
}

func OrderV3Init() OrderStateV3 { return OrderStateV3{Status: "idle", PriceCents: 499} }

func MigrateOrder(old OrderState) OrderStateV3 {
	return OrderStateV3{Inventory: old.Inventory, Status: old.Status, OrderID: old.OrderID, SKU: old.SKU, Quantity: old.Quantity, AmountCents: old.AmountCents, PriceCents: 499}
}

func OrderV3(s OrderStateV3, m Msg) OrderStateV3 {
	switch x := m.(type) {
	case PlaceOrder:
		s.OrderID = x.OrderID
		s.SKU = x.SKU
		s.Quantity = x.Quantity
		s.AmountCents = x.AmountCents
		s.Status = "waiting for stock"
		s.Inventory <- ReserveStock{OrderID: x.OrderID, SKU: x.SKU, Quantity: x.Quantity, ReplyTo: Self()}
	case StockReserved:
		s.Status = "authorizing payment"
		payment := Ask(Port("payments"), AuthorizePayment{OrderID: s.OrderID, AmountCents: s.AmountCents}).(PaymentResult)
		if payment.Approved {
			s.Status = "fulfilling"
			Port("fulfillment") <- FulfillOrder{OrderID: s.OrderID, SKU: s.SKU, Quantity: s.Quantity}
			Port("notifications") <- Notify{OrderID: s.OrderID, Message: "order confirmed"}
		}
	}
	return s
}