Is there a limit to the Goroutine that calls gen.ServerProcess.CallWithTimeout (...)?

[leonlee2013]

CallWithTimeout (to, message) can only be called in Goroutine for running ServerBehavior？

HandleCast(process *ServerProcess, message etf.Term) ServerStatus
HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)
HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)
HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

Otherwise, ProcessLoop will be blocked ： case sp.waitReply = <-sp.callbackWaitReply:

func (sp *ServerProcess) waitCallbackOrDeferr(message interface{}) {
 ...
  select {

  //case <-sp.Context().Done():
  // do not read the context state. otherwise the goroutine with running callback
  // might lock forever on exit (or on making a Call request) as nobody read
  // the callbackWaitReply channel.

  case sp.waitReply = <-sp.callbackWaitReply:
    // not nil value means callback made a Call request and waiting for reply
    if sp.waitReply == nil && len(sp.deferred) > 0 { 
      sp.mailbox = sp.deferred
    }   
    return
  }
}

[halturin]

Call*/Cast methods can be used inside gen.ServerProcess only (within Handle* callbacks only, to be specific). If you need to make a sync call to the process being outside of the actor, you should use gen.Process.Direct or gen.Process.DirectWithTimeout or gen.Process.Send for async messaging

[halturin]

btw, here is auto-translation of the documentation for the gen.Process https://ru-docs-ergo-services.translate.goog/basics/process?_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp. Its still a draft, but hope it will help you to understand some details.

[leonlee2013]

Okay, thanks

[leonlee2013]

As mentioned above, you should use Call/Cast within Handle* callback only. Using them outside of the process goroutine causing a block.

gen.ServerProcess.Cast(...) is asynchronous and should not require,
gen.ServerProcess.Call(...) must be within Handle* callback only.

func (sp *ServerProcess) Cast(to interface{}, message etf.Term) error {
  msg := etf.Term(etf.Tuple{etf.Atom("$gen_cast"), message})
  return sp.Send(to, msg)
}
func (sp *ServerProcess) Call(to interface{}, message etf.Term) (etf.Term, error) {
  return sp.CallWithTimeout(to, message, DefaultCallTimeout)
}
func (sp *ServerProcess) CallWithTimeout(to interface{}, message etf.Term, timeout int) (etf.Term, error) {
  ref := sp.MakeRef()
  from := etf.Tuple{sp.Self(), ref}
  msg := etf.Term(etf.Tuple{etf.Atom("$gen_call"), from, message})

  sp.PutSyncRequest(ref)
  if err := sp.Send(to, msg); err != nil {
    sp.CancelSyncRequest(ref)
    return nil, err
  }
  sp.callbackWaitReply <- &ref
  value, err := sp.WaitSyncReply(ref, timeout)
  return value, err
}

[halturin]

sure, the Cast method is just a wrap over the gen.Process.Send method. But it is placed along with the Call method because it handles by the HandleCast callback. If you decide to implement a custom Process behavior (like your own ServerProcess version) you should also make sure to implement the handling of etf.Term(etf.Tuple{etf.Atom("$gen_cast"), message})

[leonlee2013]

node.process.Direct(...) for gen.Application,gen.supervisor,gen.Server
gen.ServerProcess.Cast(...) is only used by gen.server,
so there is no node.process.Cast(...)
Is my understanding correct?

[halturin]

requests made with gen.Process.Direct(...) are handled by gen.Application, gen.Supervisor and gen.Server, but only the last one (gen.Server) forwards this request to the HandleDirect callback. (gen.Application and gen.Supervisor are handling this kind of message under the hood)

gen.ServerProcess.Cast(...) is only used by gen.server, so there is no node.process.Cast(...)

that's correct