properly send events and delete state server record

Author: GuzekAlan

lib/live_debugger/gen_servers/ets_table_server.ex

@@ -100,11 +100,8 @@ defmodule LiveDebugger.GenServers.EtsTableServer do
   @impl true
   def handle_call({:watch, pid}, {watcher, _}, state) do
     case Map.get(state, pid) do
-      %TableInfo{watchers: watchers} = table_info ->
-        updated_watchers = MapSet.put(watchers, watcher)
-
-        updated_state =
-          Map.put(state, pid, %{table_info | watchers: updated_watchers})
+      %TableInfo{} ->
+        updated_state = update_watchers(state, pid, &MapSet.put(&1, watcher))
 
         Process.monitor(watcher)
 
@@ -144,27 +141,32 @@ defmodule LiveDebugger.GenServers.EtsTableServer do
   defp maybe_delete_ets_table(state, pid) do
     with {%TableInfo{alive?: false} = table_info, updated_state} <- Map.pop(state, pid),
          true <- Enum.empty?(table_info.watchers) do
+      PubSubUtils.process_status_topic()
+      |> PubSubUtils.broadcast({:process_status, {:not_watched, pid}})
+
       :ets.delete(table_info.table)
-      IO.inspect(pid, label: "DELETING TABLE")
       updated_state
     else
       _ ->
         state
     end
   end
 
-  @spec remove_watcher(state(), pid()) :: {state(), [pid()]}
+  @spec remove_watcher(state(), pid()) :: {updated_state :: state(), touched_pids :: [pid()]}
   defp remove_watcher(state, watcher) when is_pid(watcher) do
-    Enum.reduce(state, {state, []}, fn {pid, %{watchers: watchers} = table_info},
-                                       {state_acc, pids} ->
+    Enum.reduce(state, {state, []}, fn {pid, %{watchers: watchers}}, {state_acc, pids} ->
       if Enum.member?(watchers, watcher) do
-        updated_state =
-          Map.put(state_acc, pid, %{table_info | watchers: MapSet.delete(watchers, watcher)})
+        updated_state = update_watchers(state_acc, pid, &MapSet.delete(&1, watcher))
 
         {updated_state, [pid | pids]}
       else
         {state_acc, pids}
       end
     end)
   end
+
+  defp update_watchers(state, pid, update_fn) when is_map_key(state, pid) do
+    table_info = Map.get(state, pid)
+    Map.put(state, pid, %{table_info | watchers: update_fn.(table_info.watchers)})
+  end
 end

lib/live_debugger/gen_servers/state_server.ex

@@ -67,12 +67,14 @@ defmodule LiveDebugger.GenServers.StateServer do
     {:noreply, state}
   end
 
-  def handle_info({:process_status, {:dead, pid}}, state) do
+  def handle_info({:process_status, {:not_watched, pid}}, state) do
     :ets.delete(@ets_table_name, record_id(pid))
 
     {:noreply, state}
   end
 
+  def handle_info({:process_status, _}, state), do: {:noreply, state}
+
   defp save_state(%Trace{pid: pid} = trace) do
     with {:ok, channel_state} <- ProcessService.state(pid) do
       record_id = record_id(pid)

lib/live_debugger/structs/lv_process.ex

@@ -16,7 +16,8 @@ defmodule LiveDebugger.Structs.LvProcess do
     :module,
     :nested?,
     :debugger?,
-    :embedded?
+    :embedded?,
+    alive?: true
   ]
 
   @type t() :: %__MODULE__{
@@ -28,7 +29,8 @@ defmodule LiveDebugger.Structs.LvProcess do
           module: module(),
           nested?: boolean(),
           embedded?: boolean(),
-          debugger?: boolean()
+          debugger?: boolean(),
+          alive?: boolean()
         }
 
   @spec new(pid :: pid(), socket :: Phoenix.LiveView.Socket.t()) :: t()

lib/live_debugger_web/hooks/linked_view.ex

@@ -7,7 +7,7 @@ defmodule LiveDebuggerWeb.Hooks.LinkedView do
     - If the `lv_process` assign is not found, it will try to find a successor LiveView process and navigate to it.
     - If no successor is found, it will navigate to the error page.
 
-    It also handles a case when the LiveView process dies by trying to find a successor LiveView process.
+    It also handles situation when process dies by updating `lv_process.alive?` field.
 
     The only thing you need to do after adding this hook is to handle loading state in the template.
     ## Example
@@ -89,7 +89,7 @@ defmodule LiveDebuggerWeb.Hooks.LinkedView do
       )
       when is_pid(pid) do
     socket
-    |> find_successor_lv_process()
+    |> make_lv_process_dead()
     |> halt()
   end
 
@@ -124,7 +124,7 @@ defmodule LiveDebuggerWeb.Hooks.LinkedView do
   end
 
   defp fetch_lv_process_with_retries(pid) do
-    fn -> fetch_with_retries(fn -> LiveViewDiscoveryService.lv_process(pid) end) end
+    fn -> fetch_with_retries(fn -> LvProcess.new(pid) end) end
   end
 
   defp fetch_with_retries(function) do
@@ -138,4 +138,12 @@ defmodule LiveDebuggerWeb.Hooks.LinkedView do
     Process.sleep(milliseconds)
     function.()
   end
+
+  defp make_lv_process_dead(
+         %{assigns: %{lv_process: %AsyncResult{ok?: true, result: result}}} = socket
+       ) do
+    lv_process = AsyncResult.ok(%LvProcess{result | alive?: false})
+
+    assign(socket, :lv_process, lv_process)
+  end
 end