github.com/asynkron/protoactor-go@v0.0.0-20240308120642-ef91a6abee75/protobuf/protoc-gen-go-grain/templates/grain.tmpl

{{ $service := . }}
var x{{ $service.Name }}Factory func() {{ $service.Name }}

// {{ $service.Name }}Factory produces a {{ $service.Name }}
func {{ $service.Name }}Factory(factory func() {{ $service.Name }}) {
	x{{ $service.Name }}Factory = factory
}

// Get{{ $service.Name }}GrainClient instantiates a new {{ $service.Name }}GrainClient with given Identity
func Get{{ $service.Name }}GrainClient(c *cluster.Cluster, id string) *{{ $service.Name }}GrainClient {
	if c == nil {
		panic(fmt.Errorf("nil cluster instance"))
	}
	if id == "" {
		panic(fmt.Errorf("empty id"))
	}
	return &{{ $service.Name }}GrainClient{Identity: id, cluster: c}
}

// Get{{ $service.Name }}Kind instantiates a new cluster.Kind for {{ $service.Name }}
func Get{{ $service.Name }}Kind(opts ...actor.PropsOption) *cluster.Kind {
	props := actor.PropsFromProducer(func() actor.Actor {
		return &{{ $service.Name }}Actor{
			Timeout: 60 * time.Second,
		}
	}, opts...)
	kind := cluster.NewKind("{{ $service.Name }}", props)
	return kind
}

// Get{{ $service.Name }}Kind instantiates a new cluster.Kind for {{ $service.Name }}
func New{{ $service.Name }}Kind(factory func() {{ $service.Name }}, timeout time.Duration, opts ...actor.PropsOption) *cluster.Kind {
	x{{ $service.Name }}Factory = factory
	props := actor.PropsFromProducer(func() actor.Actor {
		return &{{ $service.Name }}Actor{
			Timeout: timeout,
		}
	}, opts...)
	kind := cluster.NewKind("{{ $service.Name }}", props)
	return kind
}

// {{ $service.Name }} interfaces the services available to the {{ $service.Name }}
type {{ $service.Name }} interface {
	Init(ctx cluster.GrainContext)
	Terminate(ctx cluster.GrainContext)
	ReceiveDefault(ctx cluster.GrainContext)
	{{- range $method := .Methods }}
	{{ if $method.Options.Reenterable -}}
	{{ $method.Name }}(req *{{ $method.Input }}, respond func(*{{ $method.Output }}), onError func(error), ctx cluster.GrainContext) error
	{{- else -}}
	{{ $method.Name }}(req *{{ $method.Input }}, ctx cluster.GrainContext) (*{{ $method.Output }}, error)
	{{- end }}
	{{- end}}
}

// {{ $service.Name }}GrainClient holds the base data for the {{ $service.Name }}Grain
type {{ $service.Name }}GrainClient struct {
	Identity string
	cluster  *cluster.Cluster
}
{{ range $method := .Methods}}
{{ if $method.Options.Future -}}
// {{ $method.Name }}Future return a future for the execution of {{ $method.Name }} on the cluster
func (g *{{ $service.Name }}GrainClient) {{ $method.Name }}Future(r *{{ $method.Input }}, opts ...cluster.GrainCallOption) (*actor.Future, error) {
	bytes, err := proto.Marshal(r)
	if err != nil {
		return nil, err
	}

	reqMsg := &cluster.GrainRequest{MethodIndex: {{ $method.Index }}, MessageData: bytes}
	f, err := g.cluster.RequestFuture(g.Identity, "{{ $service.Name }}", reqMsg, opts...)
	if err != nil {
		return nil, fmt.Errorf("error request future: %w", err)
	}

	return f, nil
}
{{ end }}
// {{ $method.Name }} requests the execution on to the cluster with CallOptions
func (g *{{ $service.Name }}GrainClient) {{ $method.Name }}(r *{{ $method.Input }}, opts ...cluster.GrainCallOption) (*{{ $method.Output }}, error) {
	bytes, err := proto.Marshal(r)
	if err != nil {
		return nil, err
	}
	reqMsg := &cluster.GrainRequest{MethodIndex: {{ $method.Index }}, MessageData: bytes}
	resp, err := g.cluster.Request(g.Identity, "{{ $service.Name }}", reqMsg, opts...)
	if err != nil {
		return nil, fmt.Errorf("error request: %w", err)
	}
	switch msg := resp.(type) {
	case *{{ $method.Output }}:
		return msg, nil
	case *cluster.GrainErrorResponse:
		if msg == nil {
			return nil, nil
		}
		return nil, msg
	default:
		return nil, fmt.Errorf("unknown response type %T", resp)
	}
}
{{ end }}
// {{ $service.Name }}Actor represents the actor structure
type {{ $service.Name }}Actor struct {
	ctx     cluster.GrainContext
	inner   {{ $service.Name }}
	Timeout time.Duration
}

// Receive ensures the lifecycle of the actor for the received message
func (a *{{ $service.Name }}Actor) Receive(ctx actor.Context) {
	switch msg := ctx.Message().(type) {
	case *actor.Started: //pass
	case *cluster.ClusterInit:
		a.ctx = cluster.NewGrainContext(ctx, msg.Identity, msg.Cluster)
		a.inner = x{{ $service.Name }}Factory()
		a.inner.Init(a.ctx)

		if a.Timeout > 0 {
			ctx.SetReceiveTimeout(a.Timeout)
		}
	case *actor.ReceiveTimeout:
		ctx.Poison(ctx.Self())
	case *actor.Stopped:
		a.inner.Terminate(a.ctx)
	case actor.AutoReceiveMessage: // pass
	case actor.SystemMessage: // pass

	case *cluster.GrainRequest:
		switch msg.MethodIndex {
		{{ range $method := .Methods -}}
		case {{ $method.Index }}:
			req := &{{ $method.Input }}{}
			err := proto.Unmarshal(msg.MessageData, req)
			if err != nil {
				ctx.Logger().Error("[Grain] {{ $method.Name }}({{ $method.Input }}) proto.Unmarshal failed.", slog.Any("error", err))
				resp := cluster.NewGrainErrorResponse(cluster.ErrorReason_INVALID_ARGUMENT, err.Error()).
					WithMetadata(map[string]string{
						"argument": req.String(),
				})
				ctx.Respond(resp)
				return
			}
			{{ if $method.Options.Reenterable -}}
			err = a.inner.{{ $method.Name }}(req, respond[*{{ $method.Output }}](a.ctx), a.onError, a.ctx)
			{{ else }}
			r0, err := a.inner.{{ $method.Name }}(req, a.ctx)
			{{ end -}}
			if err != nil {
				resp := cluster.FromError(err)
				ctx.Respond(resp)
				return
			}
			{{ if not $method.Options.Reenterable -}}
			ctx.Respond(r0)
			{{ end -}}
		{{ end -}}
		}
	default:
		a.inner.ReceiveDefault(a.ctx)
	}
}

// onError should be used in ctx.ReenterAfter
// you can just return error in reenterable method for other errors
func (a *{{ $service.Name }}Actor) onError(err error) {
	resp := cluster.FromError(err)
	a.ctx.Respond(resp)
}