feat(cfg): Hyper.Cfg.Tools facade; define missing privileged tool paths

Author: markovejnovic

lib/hyper/cfg/tools.ex

@@ -0,0 +1,64 @@
+defmodule Hyper.Cfg.Tools do
+  @moduledoc """
+  Paths to every external binary Hyper runs, read from the `[tools]` table.
+
+  The privileged tools (`firecracker`, `jailer`, `dmsetup`, `losetup`,
+  `blockdev`) are read **only** from `/etc/hyper/config.toml` — the file the
+  setuid helper also parses, so node and helper can never disagree on a
+  root-impacting path. The node-only tools (`skopeo`, `mke2fs`, `umoci`,
+  `suidhelper`) run unprivileged, so `/etc/hyper/config.exs` may override them
+  (e.g. a path from a secrets manager), then `config.toml`, then the default.
+  """
+
+  import Hyper.Cfg, only: [get_cfg: 1]
+
+  @doc "Firecracker binary. Required — raises if `[tools] firecracker` is unset."
+  @spec firecracker :: Path.t()
+  def firecracker, do: get_cfg(toml: "tools.firecracker")
+
+  @doc "Non-raising `firecracker/0`."
+  @spec firecracker_configured :: {:ok, Path.t()} | :error
+  def firecracker_configured, do: Hyper.Cfg.Toml.fetch("tools.firecracker")
+
+  @doc "Jailer binary. Required — raises if `[tools] jailer` is unset."
+  @spec jailer :: Path.t()
+  def jailer, do: get_cfg(toml: "tools.jailer")
+
+  @doc "Non-raising `jailer/0`."
+  @spec jailer_configured :: {:ok, Path.t()} | :error
+  def jailer_configured, do: Hyper.Cfg.Toml.fetch("tools.jailer")
+
+  @doc "dmsetup binary (privileged, config.toml-only)."
+  @spec dmsetup :: Path.t()
+  def dmsetup, do: get_cfg(toml: "tools.dmsetup", default: "/usr/sbin/dmsetup")
+
+  @doc "losetup binary (privileged, config.toml-only)."
+  @spec losetup :: Path.t()
+  def losetup, do: get_cfg(toml: "tools.losetup", default: "/usr/sbin/losetup")
+
+  @doc "blockdev binary (privileged, config.toml-only)."
+  @spec blockdev :: Path.t()
+  def blockdev, do: get_cfg(toml: "tools.blockdev", default: "/usr/sbin/blockdev")
+
+  @doc "skopeo binary (node tool). config.exs > config.toml > `skopeo` on PATH."
+  @spec skopeo :: String.t()
+  def skopeo, do: get_cfg(runtime: {__MODULE__, :skopeo}, toml: "tools.skopeo", default: "skopeo")
+
+  @doc "mke2fs binary (node tool). config.exs > config.toml > `mke2fs` on PATH."
+  @spec mke2fs :: String.t()
+  def mke2fs, do: get_cfg(runtime: {__MODULE__, :mke2fs}, toml: "tools.mke2fs", default: "mke2fs")
+
+  @doc "umoci binary (node tool), or `nil` to let Hyper download a pinned release."
+  @spec umoci :: String.t() | nil
+  def umoci, do: get_cfg(runtime: {__MODULE__, :umoci}, toml: "tools.umoci", default: nil)
+
+  @doc "setuid device helper (node tool). config.exs > config.toml > install default."
+  @spec suidhelper :: String.t()
+  def suidhelper,
+    do:
+      get_cfg(
+        runtime: {__MODULE__, :suidhelper},
+        toml: "tools.suidhelper",
+        default: "/usr/local/bin/hyper-suidhelper"
+      )
+end

lib/hyper/img/oci_loader.ex

@@ -81,9 +81,9 @@ defmodule Hyper.Img.OciLoader do
   def test_system do
     with {:ok, _arch} <- Sys.Arch.current() do
       tools = [
-        {"skopeo", Config.skopeo_path()},
+        {"skopeo", Hyper.Cfg.Tools.skopeo()},
         {"umoci", Umoci.bin()},
-        {"mke2fs", Config.mke2fs_path()}
+        {"mke2fs", Hyper.Cfg.Tools.mke2fs()}
       ]
 
       missing = for {name, path} <- tools, System.find_executable(path) == nil, do: name
@@ -137,7 +137,7 @@ defmodule Hyper.Img.OciLoader do
     bundle = Path.join(tmp, "bundle")
 
     skopeo =
-      cmd(Config.skopeo_path(), [
+      cmd(Hyper.Cfg.Tools.skopeo(), [
         "copy",
         "--override-os",
         "linux",
@@ -192,7 +192,7 @@ defmodule Hyper.Img.OciLoader do
       ["-t", "ext4", "-F", "-q", "-N", to_string(inodes), "-d", rootfs, staged] ++
         ["#{Information.as_mib(size)}M"]
 
-    case tag(cmd(Config.mke2fs_path(), args), :mke2fs) do
+    case tag(cmd(Hyper.Cfg.Tools.mke2fs(), args), :mke2fs) do
       :ok ->
         {:ok, staged}
 

lib/hyper/img/oci_loader/umoci.ex

@@ -40,7 +40,7 @@ defmodule Hyper.Img.OciLoader.Umoci do
   """
   @spec ensure_installed() :: :ok | {:error, term()}
   def ensure_installed do
-    if Config.umoci_path() != nil do
+    if Hyper.Cfg.Tools.umoci() != nil do
       :ok
     else
       with {:ok, arch} <- Sys.Arch.current() do
@@ -57,7 +57,7 @@ defmodule Hyper.Img.OciLoader.Umoci do
   """
   @spec bin() :: Path.t()
   def bin do
-    case Config.umoci_path() do
+    case Hyper.Cfg.Tools.umoci() do
       nil ->
         {:ok, arch} = Sys.Arch.current()
         default_path(arch)

lib/hyper/suid_helper.ex

@@ -30,7 +30,7 @@ defmodule Hyper.SuidHelper do
   @spec exec([String.t()]) :: {:ok, map()} | {:error, err()}
   @decorate with_span("Hyper.SuidHelper.exec", include: [:argv])
   def exec(argv) do
-    case System.cmd(Hyper.Config.suid_helper(), argv, stderr_to_stdout: true) do
+    case System.cmd(Hyper.Cfg.Tools.suidhelper(), argv, stderr_to_stdout: true) do
       {out, 0} -> {:ok, Jason.decode!(out)}
       {out, code} -> {:error, {code, String.trim(out)}}
     end
@@ -91,7 +91,7 @@ defmodule Hyper.SuidHelper do
 
   @spec helper_present() :: :ok | {:error, :suid_helper_not_found}
   defp helper_present do
-    if System.find_executable(Hyper.Config.suid_helper()),
+    if System.find_executable(Hyper.Cfg.Tools.suidhelper()),
       do: :ok,
       else: {:error, :suid_helper_not_found}
   end

lib/hyper/suid_helper/blockdev.ex

@@ -11,7 +11,7 @@ defmodule Hyper.SuidHelper.Blockdev do
   @spec device_sectors(Path.t()) :: {:ok, pos_integer()} | {:error, err()}
   @decorate with_span("Hyper.SuidHelper.Blockdev.device_sectors", include: [:path])
   def device_sectors(path) do
-    case SuidHelper.exec(["blockdev", "--bin", Hyper.Config.blockdev_path(), "--getsz", path]) do
+    case SuidHelper.exec(["blockdev", "--bin", Hyper.Cfg.Tools.blockdev(), "--getsz", path]) do
       {:ok, %{"sectors" => n}} -> {:ok, n}
       {:error, _} = err -> err
     end
@@ -21,7 +21,7 @@ defmodule Hyper.SuidHelper.Blockdev do
   @spec test_system() :: :ok | {:error, :blockdev_not_found}
   @decorate with_span("Hyper.SuidHelper.Blockdev.test_system")
   def test_system do
-    if System.find_executable(Hyper.Config.blockdev_path()),
+    if System.find_executable(Hyper.Cfg.Tools.blockdev()),
       do: :ok,
       else: {:error, :blockdev_not_found}
   end

lib/hyper/suid_helper/dmsetup.ex

@@ -62,7 +62,7 @@ defmodule Hyper.SuidHelper.Dmsetup do
     case SuidHelper.exec([
            "dmsetup",
            "--bin",
-           Hyper.Config.dmsetup_path(),
+           Hyper.Cfg.Tools.dmsetup(),
            "remove",
            "--retry",
            name
@@ -77,7 +77,7 @@ defmodule Hyper.SuidHelper.Dmsetup do
   @decorate with_span("Hyper.SuidHelper.Dmsetup.message", include: [:name, :message])
   def message(name, message) do
     argv =
-      ["dmsetup", "--bin", Hyper.Config.dmsetup_path(), "message", name, "--message", message]
+      ["dmsetup", "--bin", Hyper.Cfg.Tools.dmsetup(), "message", name, "--message", message]
 
     case SuidHelper.exec(argv) do
       {:ok, _} -> :ok
@@ -92,7 +92,7 @@ defmodule Hyper.SuidHelper.Dmsetup do
   @spec test_system() :: :ok | {:error, term()}
   @decorate with_span("Hyper.SuidHelper.Dmsetup.test_system")
   def test_system do
-    if System.find_executable(Hyper.Config.dmsetup_path()),
+    if System.find_executable(Hyper.Cfg.Tools.dmsetup()),
       do: test_targets(),
       else: {:error, :dmsetup_not_found}
   end
@@ -101,7 +101,7 @@ defmodule Hyper.SuidHelper.Dmsetup do
   @spec test_targets() :: :ok | {:error, term()}
   @decorate with_span("Hyper.SuidHelper.Dmsetup.test_targets")
   def test_targets do
-    case System.cmd(Hyper.Config.dmsetup_path(), ["targets"], stderr_to_stdout: true) do
+    case System.cmd(Hyper.Cfg.Tools.dmsetup(), ["targets"], stderr_to_stdout: true) do
       {out, 0} ->
         have = parse_targets(out)
         missing = Enum.reject(@required_targets, &MapSet.member?(have, &1))
@@ -146,7 +146,7 @@ defmodule Hyper.SuidHelper.Dmsetup do
   @spec create(String.t(), String.t(), [String.t()]) :: {:ok, Path.t()} | {:error, err()}
   defp create(name, table, flags) do
     argv =
-      ["dmsetup", "--bin", Hyper.Config.dmsetup_path(), "create", name] ++
+      ["dmsetup", "--bin", Hyper.Cfg.Tools.dmsetup(), "create", name] ++
         flags ++ ["--table", table]
 
     case SuidHelper.exec(argv) do

lib/hyper/suid_helper/losetup.ex

@@ -11,7 +11,7 @@ defmodule Hyper.SuidHelper.Losetup do
   @spec attach_ro(Path.t()) :: {:ok, Path.t()} | {:error, err()}
   @decorate with_span("Hyper.SuidHelper.Losetup.attach_ro", include: [:path])
   def attach_ro(path) do
-    case SuidHelper.exec(["losetup", "--bin", Hyper.Config.losetup_path(), "attach", path]) do
+    case SuidHelper.exec(["losetup", "--bin", Hyper.Cfg.Tools.losetup(), "attach", path]) do
       {:ok, %{"device" => dev}} -> {:ok, dev}
       {:error, _} = err -> err
     end
@@ -24,7 +24,7 @@ defmodule Hyper.SuidHelper.Losetup do
     case SuidHelper.exec([
            "losetup",
            "--bin",
-           Hyper.Config.losetup_path(),
+           Hyper.Cfg.Tools.losetup(),
            "attach",
            "--rw",
            path
@@ -38,7 +38,7 @@ defmodule Hyper.SuidHelper.Losetup do
   @spec detach(Path.t()) :: :ok | {:error, err()}
   @decorate with_span("Hyper.SuidHelper.Losetup.detach", include: [:dev])
   def detach(dev) do
-    case SuidHelper.exec(["losetup", "--bin", Hyper.Config.losetup_path(), "detach", dev]) do
+    case SuidHelper.exec(["losetup", "--bin", Hyper.Cfg.Tools.losetup(), "detach", dev]) do
       {:ok, _} -> :ok
       {:error, _} = err -> err
     end
@@ -48,7 +48,7 @@ defmodule Hyper.SuidHelper.Losetup do
   @spec test_system() :: :ok | {:error, :losetup_not_found}
   @decorate with_span("Hyper.SuidHelper.Losetup.test_system")
   def test_system do
-    if System.find_executable(Hyper.Config.losetup_path()),
+    if System.find_executable(Hyper.Cfg.Tools.losetup()),
       do: :ok,
       else: {:error, :losetup_not_found}
   end

test/hyper/cfg/tools_test.exs

@@ -0,0 +1,49 @@
+defmodule Hyper.Cfg.ToolsTest do
+  use ExUnit.Case, async: false
+
+  alias Hyper.Cfg.Tools
+  alias Hyper.Cfg.Toml
+
+  setup do
+    # Hermetic: empty TOML cache so we assert built-in defaults, not the
+    # ambient /etc/hyper/config.toml. Restore the real cache afterward.
+    Toml.put_cache(%{})
+    on_exit(fn -> Toml.reload() end)
+    :ok
+  end
+
+  test "privileged tools with no config.toml fall back to their sbin defaults" do
+    assert Tools.dmsetup() == "/usr/sbin/dmsetup"
+    assert Tools.losetup() == "/usr/sbin/losetup"
+    assert Tools.blockdev() == "/usr/sbin/blockdev"
+  end
+
+  test "privileged tool paths come only from the [tools] table" do
+    Toml.put_cache(%{"tools" => %{"dmsetup" => "/custom/dmsetup"}})
+    assert Tools.dmsetup() == "/custom/dmsetup"
+  end
+
+  test "node tools default to bare PATH names / known install path" do
+    assert Tools.skopeo() == "skopeo"
+    assert Tools.mke2fs() == "mke2fs"
+    assert Tools.suidhelper() == "/usr/local/bin/hyper-suidhelper"
+    assert Tools.umoci() == nil
+  end
+
+  test "node tools: config.exs (runtime) overrides config.toml" do
+    Toml.put_cache(%{"tools" => %{"skopeo" => "/from/toml"}})
+    assert Tools.skopeo() == "/from/toml"
+
+    Application.put_env(:hyper, Tools, skopeo: "/from/exs")
+    assert Tools.skopeo() == "/from/exs"
+  after
+    Application.delete_env(:hyper, Tools)
+  end
+
+  test "required tools raise (non-raising form returns :error) when unset" do
+    assert Tools.firecracker_configured() == :error
+    assert Tools.jailer_configured() == :error
+    assert_raise Hyper.Cfg.MissingError, fn -> Tools.firecracker() end
+    assert_raise Hyper.Cfg.MissingError, fn -> Tools.jailer() end
+  end
+end