Quickstart

package main

import (
	"context"
	"os"
	"os/signal"
	"syscall"
	"time"

	goakt "github.com/tochemey/goakt/v4/actor"
	"github.com/tochemey/goakt/v4/log"
)

// Greet asks the actor to greet someone; Greeting is its reply.
type Greet struct{ Name string }

type Greeting struct{ Message string }

// Greeter is the actor. State lives in unexported fields; no locks are
// needed because an actor processes one message at a time.
type Greeter struct {
	greeted int
}

var _ goakt.Actor = (*Greeter)(nil)

func (x *Greeter) PreStart(*goakt.Context) error { return nil }

func (x *Greeter) Receive(ctx *goakt.ReceiveContext) {
	switch msg := ctx.Message().(type) {
	case *Greet:
		x.greeted++
		ctx.Response(&Greeting{Message: "Hello, " + msg.Name + "!"})
	default:
		ctx.Unhandled()
	}
}

func (x *Greeter) PostStop(*goakt.Context) error { return nil }

func main() {
	ctx := context.Background()
	logger := log.DefaultLogger

	system, err := goakt.NewActorSystem("quickstart", goakt.WithLogger(logger))
	if err != nil {
		logger.Fatal(err)
	}

	if err := system.Start(ctx); err != nil {
		logger.Fatal(err)
	}

	pid, err := system.Spawn(ctx, "greeter", &Greeter{})
	if err != nil {
		logger.Fatal(err)
	}

	response, err := goakt.Ask(ctx, pid, &Greet{Name: "World"}, time.Second)
	if err != nil {
		logger.Fatal(err)
	}

	logger.Info(response.(*Greeting).Message)

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
	<-sig

	_ = system.Stop(ctx)
}

go run main.go