dont remove table when any process is watching

Author: GuzekAlan

lib/live_debugger/gen_servers/ets_table_server.ex

@@ -3,31 +3,43 @@ defmodule LiveDebugger.GenServers.EtsTableServer do
   This gen_server is responsible for managing ETS tables.
   """
 
+  defmodule TableInfo do
+    defstruct [:table, alive?: true, watchers: MapSet.new()]
+
+    @type t() :: %__MODULE__{
+            alive?: boolean(),
+            table: :ets.table(),
+            watchers: MapSet.t()
+          }
+  end
+
   use GenServer
 
+  alias __MODULE__.TableInfo
   alias LiveDebugger.Utils.PubSub, as: PubSubUtils
 
-  @ets_table_name :lvdbg_traces
+  @type state() :: %{pid() => TableInfo.t()}
 
-  @type table_refs() :: %{pid() => :ets.table()}
+  @ets_table_name :lvdbg_traces
 
   ## API
 
   @callback table(pid :: pid()) :: :ets.table()
-  @callback delete_table(pid :: pid()) :: :ok
+  @callback watch(pid :: pid()) :: :ok | {:error, term()}
 
   @doc """
   Returns ETS table reference.
   It creates table if none is associated with given pid
   """
-  @spec table(pid :: pid()) :: :ets.table()
   def table(pid) when is_pid(pid), do: impl().table(pid)
 
   @doc """
-  If table for given `pid` exists it deletes it from ETS.
+  Adds watcher to indicate when to delete table from ETS.
+  It uses pid of process which the function was called.
   """
-  @spec delete_table(pid :: pid()) :: :ok
-  def delete_table(pid) when is_pid(pid), do: impl().delete_table(pid)
+  def watch(pid) when is_pid(pid) do
+    impl().watch(pid)
+  end
 
   ## GenServer
 
@@ -41,33 +53,64 @@ defmodule LiveDebugger.GenServers.EtsTableServer do
     {:ok, %{}}
   end
 
+  # This is for debugged processes monitored
   @impl true
-  def handle_info({:DOWN, _, :process, closed_pid, _}, table_refs) do
-    {_, table_refs} = delete_ets_table(closed_pid, table_refs)
+  def handle_info({:DOWN, _, :process, closed_pid, _}, state)
+      when is_map_key(state, closed_pid) do
+    state =
+      state
+      |> Map.update!(closed_pid, fn table_info -> %{table_info | alive?: false} end)
+      |> maybe_delete_ets_table(closed_pid)
 
     PubSubUtils.process_status_topic()
     |> PubSubUtils.broadcast({:process_status, {:dead, closed_pid}})
 
-    {:noreply, table_refs}
+    {:noreply, state}
+  end
+
+  # This is for watchers processes
+  @impl true
+  def handle_info({:DOWN, _, :process, closed_pid, _}, state) do
+    {updated_state, touched_pids} = remove_watcher(state, closed_pid)
+
+    updated_state =
+      touched_pids
+      |> Enum.reduce(updated_state, fn pid, state_acc ->
+        maybe_delete_ets_table(state_acc, pid)
+      end)
+
+    {:noreply, updated_state}
   end
 
   @impl true
-  def handle_call({:get_or_create_table, pid}, _from, table_refs) do
-    case Map.get(table_refs, pid) do
+  def handle_call({:get_or_create_table, pid}, _from, state) do
+    case Map.get(state, pid) do
       nil ->
         ref = create_ets_table()
         Process.monitor(pid)
-        {:reply, ref, Map.put(table_refs, pid, ref)}
+        {:reply, ref, Map.put(state, pid, %TableInfo{table: ref})}
 
-      ref ->
-        {:reply, ref, table_refs}
+      %TableInfo{table: ref} ->
+        {:reply, ref, state}
     end
   end
 
   @impl true
-  def handle_call({:delete_table, pid}, _from, table_refs) do
-    {_, table_refs} = delete_ets_table(pid, table_refs)
-    {:reply, :ok, table_refs}
+  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})
+
+        Process.monitor(watcher)
+
+        {:reply, :ok, updated_state}
+
+      _ ->
+        {:reply, {:error, :process_not_found}, state}
+    end
   end
 
   defp impl() do
@@ -85,8 +128,8 @@ defmodule LiveDebugger.GenServers.EtsTableServer do
     end
 
     @impl true
-    def delete_table(pid) do
-      GenServer.call(@server_module, {:delete_table, pid}, 1000)
+    def watch(pid) do
+      GenServer.call(@server_module, {:watch, pid}, 1000)
     end
   end
 
@@ -95,15 +138,30 @@ defmodule LiveDebugger.GenServers.EtsTableServer do
     :ets.new(@ets_table_name, [:ordered_set, :public])
   end
 
-  @spec delete_ets_table(pid(), table_refs()) :: {boolean(), table_refs()}
-  defp delete_ets_table(pid, table_refs) do
-    case Map.pop(table_refs, pid) do
-      {nil, table_refs} ->
-        {false, table_refs}
-
-      {ref, updated_table_refs} ->
-        :ets.delete(ref)
-        {true, updated_table_refs}
+  @spec maybe_delete_ets_table(state(), pid()) :: state()
+  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
+      :ets.delete(table_info.table)
+      updated_state
+    else
+      _ ->
+        state
     end
   end
+
+  @spec remove_watcher(state(), pid()) :: {state(), [pid()]}
+  defp remove_watcher(state, watcher) when is_pid(watcher) do
+    Enum.reduce(state, {state, []}, fn {pid, %{watchers: watchers} = table_info},
+                                       {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, [pid | pids]}
+      else
+        {state_acc, pids}
+      end
+    end)
+  end
 end

lib/live_debugger_web/hooks/linked_view.ex

@@ -63,6 +63,8 @@ defmodule LiveDebuggerWeb.Hooks.LinkedView do
     PubSubUtils.process_status_topic()
     |> PubSubUtils.subscribe!()
 
+    LiveDebugger.GenServers.EtsTableServer.watch(fetched_lv_process.pid)
+
     socket
     |> assign(:lv_process, AsyncResult.ok(fetched_lv_process))
     |> halt()