Gracefully shutdown child of dynamic supervisor

The only way for an external process to stop a exit trapping process (ungracefully) is to use :kill reason. Otherwise the signal will be converted to a message for the exit trapping process to handle. It can decide if it shuts down or not based on the message.

Hello @LostKobrakai
Thank your for reaching out. You pointed to the crux of the problem. Why does the child ignore/drop the exit signal with :nromal from its parent? Do you have any suggestions for debugging the issue? For my use case, it’s better for the child process to go down gracefully.

I have not been able to reach a meaningful conclusion after reading the docs.

How do you call Process.exit(child, :normal) from parent, when parent is a dynamic supervisor?
Can you provide the code snippet?

That depends on the implementation of the child. It can do whatever it wants when handling the exit message.

Hi @hst337
Thanks for reaching out. This is where I send the exit signal to the child from the dynamic supervisor. It’s part of a function which issues the terminate signal to the child process and removes artifacts related to the child:

def clean_up(gv_spec)  do
# cleanup  
  case :pg.get_members(gv_spec.id) do
    [] ->
       Logger.info(%{msg: "there is no gv for given instance", id: gv_spec.id})
 
   [pid | _] ->
       Process.exit(pid, :normal)
  end
# cleanup  continued
end

I’m attaching a code snippet which displays how I’m trapping exits for the child, hope it helps:

@impl :gen_statem
def init(%{spec: gv_spec, config: config}) do 
# initial processing
   Process.flag(:trap_exit, true)
# create gv_spec   
   join_pg(gv_spec) 
# variable  setting : event, data, state
   {:ok, state, data, event}
end

A terminate function is also present in the child:

@impl :gen_statem
def terminate(reason, %{spec: gv_spec} = state, data) do                                                                                                                           
   leave_pg(gv_spec)
   Logger.warn(%{msg: "terminating", reason: reason, id: gv_spec.id})
end  

terminate is only called when the process actually shuts down. The exit message would be handled in a handle_event with event type :info (handle_info elsewhere).

Thanks for the feedback @LostKobrakai. My goal was to demonstrate that the terminate function has been implemented. As you pointed out, since the process does not terminate as expected, it doesn’t get called. To address your original point, a handle_event with event type :info is present in the code base.

Does it stop the process when it receives the exit message?

This code is called not from dynamic supervisor process, I can assure you. Perhaps this is called from dynamic supervisor module, but not process. There is actually no non-hacky way to call anything from any supervisor process (unless it is a supervisor written from scratch).

Considering the trap_exit.
Any OTP compliant process with trap_exit behaves this way:
If exit signal is received from the parent process (this can be checked in Process.get()), it is handled in a way if the child was not trapping exits. And, if the child receives exit signal from any non-parent process, it is handled as a message in handle_info (or in handle_event or state function in case of gen_statem)