Actors now terminate normally once the choreography is done

Author: ashton314

lib/chorex/runtime.ex

@@ -116,7 +116,7 @@ defmodule Chorex.Runtime do
 
   def handle_continue({:finish_choreography, ret_val}, %RuntimeState{} = state) do
     send(state.vars.parent, {:chorex_return, state.actor, ret_val})
-    {:noreply, state}
+    {:stop, :normal, nil}
   end
 
   defmacro __using__(_args) do

lib/chorex/runtime_monitor.ex

@@ -118,7 +118,25 @@ defmodule Chorex.RuntimeMonitor do
   end
 
   @impl true
+  def handle_info({:DOWN, _down_ref, :process, _pid, :normal}, state) do
+    # process terminated normally (end of choreography)
+
+    ok_to_finish =
+      state.actors
+      |> Enum.map(fn {_, {_ref, pid}} -> pid end)
+      |> Enum.map(&Process.alive?/1)
+      |> Enum.all?(& not &1)
+
+    if ok_to_finish do
+      {:stop, :normal, nil}
+    else
+      {:noreply, state}
+    end
+  end
+
   def handle_info({:DOWN, down_ref, :process, _pid, _reason}, state) do
+    # process crashed
+
     state_ = revive(down_ref, state)
     network = get_config_from_state(state_)
 

lib/chorex/runtime_supervisor.ex

@@ -9,17 +9,20 @@ defmodule Chorex.RuntimeSupervisor do
 
   @impl true
   def init(_init_arg) do
-	DynamicSupervisor.init(strategy: :one_for_one)
+    DynamicSupervisor.init(strategy: :one_for_one)
   end
 
   def start_link(session_token) do
-    DynamicSupervisor.start_link(__MODULE__,
-                                 [],
-                                 name: {:via, Registry, {@registry_name, session_token}})
+    DynamicSupervisor.start_link(
+      __MODULE__,
+      [],
+      name: {:via, Registry, {@registry_name, session_token}}
+    )
   end
 
   def start_child(sup_name, mod_name, arg) do
-    spec = %{id: mod_name, start: {GenServer, :start_link, [mod_name, arg]}}
+    # restart is temporary; the RuntimeMonitor takes care of restarting crashed processes
+    spec = %{id: mod_name, start: {GenServer, :start_link, [mod_name, arg]}, restart: :temporary}
     DynamicSupervisor.start_child(sup_name, spec)
   end
 end

test/mini_test.exs

@@ -7,7 +7,7 @@ defmodule MiniTest do
       def run() do
         MtAlice.one() ~> MtBob.(x)
         MtAlice.two() ~> MtBob.(y)
-        MtBob.(x + y)
+        MtBob.work(x + y)
       end
     end
   end
@@ -24,10 +24,15 @@ defmodule MiniTest do
 
   defmodule MyMtBob do
     use MiniTestChor.Chorex, :mtbob
+
+    @impl true
+    def work(n) do
+      n
+    end
   end
 
   test "smallest choreography test" do
     Chorex.start(MiniTestChor.Chorex, %{MtAlice => MyMtAlice, MtBob => MyMtBob}, [])
-    assert_receive({:chorex_return, MtBob, 42})
+    assert_receive({:chorex_return, MtBob, 42}, 500)
   end
 end