feat(img): register mutable layers by vm_id; expose active_vm_ids/0

Adds a per-node Registry (Hyper.Node.Img.MutableRegistry) keyed by vm_id and
names each Img.Mutable through it, giving a one-mutable-per-vm invariant and a
cheap, non-blocking list of live mutable vm_ids for the Reaper to consult.

Author: markovejnovic

lib/hyper/node/img.ex

@@ -20,6 +20,7 @@ defmodule Hyper.Node.Img do
   alias Hyper.Node.Img.ThinPool
 
   @registry Hyper.Node.Img.Registry
+  @mutable_registry Hyper.Node.Img.MutableRegistry
   @server_sup Hyper.Node.Img.Supervisor
   @mutable_sup Hyper.Node.Img.MutableSupervisor
 
@@ -31,6 +32,7 @@ defmodule Hyper.Node.Img do
   def init(_opts) do
     children = [
       {Registry, keys: :unique, name: @registry},
+      {Registry, keys: :unique, name: @mutable_registry},
       ThinPool,
       {DynamicSupervisor, strategy: :one_for_one, name: @server_sup},
       {DynamicSupervisor, strategy: :one_for_one, name: @mutable_sup}
@@ -42,6 +44,9 @@ defmodule Hyper.Node.Img do
   @doc false
   def registry, do: @registry
 
+  @doc false
+  def mutable_registry, do: @mutable_registry
+
   @doc "Activate `img_id` on this node: start (or reuse) its image server."
   @spec activate(Hyper.Img.id()) :: {:ok, pid()} | {:error, term()}
   def activate(img_id) do

lib/hyper/node/img/mutable.ex

@@ -47,7 +47,8 @@ defmodule Hyper.Node.Img.Mutable do
   end
 
   @spec start_link(Opts.t()) :: GenServer.on_start()
-  def start_link(%Opts{} = opts), do: GenServer.start_link(__MODULE__, opts)
+  def start_link(%Opts{vm_id: vm_id} = opts),
+    do: GenServer.start_link(__MODULE__, opts, name: via(vm_id))
 
   @spec blk_path(GenServer.server()) :: Path.t()
   def blk_path(server), do: GenServer.call(server, :blk_path)
@@ -146,6 +147,14 @@ defmodule Hyper.Node.Img.Mutable do
   @spec dm_name(Hyper.Vm.Id.t()) :: String.t()
   def dm_name(vm_id), do: "hyper-rw-#{sanitize(vm_id)}"
 
+  @doc "vm_ids of every live mutable layer on this node."
+  @spec active_vm_ids() :: [Hyper.Vm.Id.t()]
+  def active_vm_ids do
+    Registry.select(Img.mutable_registry(), [{{:"$1", :_, :_}, [], [:"$1"]}])
+  end
+
+  defp via(vm_id), do: {:via, Registry, {Img.mutable_registry(), vm_id}}
+
   defp sanitize(id), do: String.replace(id, ~r/[^A-Za-z0-9._-]/, "_")
 
   @spec drop(State.t(), pid()) :: State.t()

test/hyper/node/img/mutable_test.exs

@@ -0,0 +1,66 @@
+defmodule Hyper.Node.Img.MutableTest do
+  use ExUnit.Case, async: false
+
+  alias Hyper.Node.Img
+  alias Hyper.Node.Img.Mutable
+
+  setup do
+    # The full app does not start in the test env, so stand up just the registry
+    # the mutable layers register into. Reuse the real name so we exercise the
+    # exact lookup `active_vm_ids/0` performs.
+    name = Img.mutable_registry()
+
+    unless Process.whereis(name) do
+      start_supervised!({Registry, keys: :unique, name: name})
+    end
+
+    :ok
+  end
+
+  defp register_live(vm_id) do
+    test = self()
+
+    {:ok, pid} =
+      Task.start_link(fn ->
+        {:ok, _} = Registry.register(Img.mutable_registry(), vm_id, nil)
+        send(test, {:registered, vm_id})
+        Process.sleep(:infinity)
+      end)
+
+    assert_receive {:registered, ^vm_id}
+    pid
+  end
+
+  test "active_vm_ids lists the vm_ids of every live mutable layer" do
+    register_live("vm-a")
+    register_live("vm-b")
+
+    assert Enum.sort(Mutable.active_vm_ids()) == ["vm-a", "vm-b"]
+  end
+
+  test "active_vm_ids drops a vm_id once its mutable layer dies" do
+    pid = register_live("vm-gone")
+    ref = Process.monitor(pid)
+    Process.unlink(pid)
+    Process.exit(pid, :kill)
+    assert_receive {:DOWN, ^ref, :process, ^pid, _}
+
+    # Registry removes the entry on the registered process's :DOWN. Poll briefly
+    # so the test is robust to that async unregister without a fixed sleep.
+    assert eventually(fn -> Mutable.active_vm_ids() == [] end)
+  end
+
+  defp eventually(fun, attempts \\ 50) do
+    cond do
+      fun.() ->
+        true
+
+      attempts == 0 ->
+        false
+
+      true ->
+        Process.sleep(2)
+        eventually(fun, attempts - 1)
+    end
+  end
+end