feat(cfg): Hyper.Cfg.Dirs facade; define firecracker_install_dir

Creates Hyper.Cfg.Dirs with work_dir/0 (config.toml-only, default
/srv/hyper) and all 8 derived directory accessors. Migrates every
call-site away from Hyper.Config.*; removes now-unused aliases in
img.ex, oci_loader.ex, umoci.ex. Resolves the last undefined-accessor
warning: firecracker_install_dir/0.

Author: markovejnovic

lib/hyper/cfg/dirs.ex

@@ -0,0 +1,47 @@
+defmodule Hyper.Cfg.Dirs do
+  @moduledoc """
+  The node's work directory and every directory derived from it.
+
+  `work_dir` is the single configurable root (`config.toml`-only, shared with the
+  setuid helper); everything else is a fixed sub-path so the node and helper
+  agree on layout without a second key to keep in sync.
+  """
+
+  import Hyper.Cfg, only: [get_cfg: 1]
+
+  @doc "Root work directory for this node. config.toml `work_dir`, default `/srv/hyper`."
+  @spec work_dir :: Path.t()
+  def work_dir, do: get_cfg(toml: "work_dir", default: "/srv/hyper")
+
+  @doc "Read-only image layer store (`<work_dir>/layers`)."
+  @spec layer_dir :: Path.t()
+  def layer_dir, do: Path.join(work_dir(), "layers")
+
+  @doc "Per-VM control/gRPC sockets (`<work_dir>/socks`)."
+  @spec socket_dir :: Path.t()
+  def socket_dir, do: Path.join(work_dir(), "socks")
+
+  @doc "Per-VM copy-on-write writable layers (`<work_dir>/scratch`)."
+  @spec scratch_dir :: Path.t()
+  def scratch_dir, do: Path.join(work_dir(), "scratch")
+
+  @doc "Per-VM chroot directories (`<work_dir>/jails`)."
+  @spec chroot_base :: Path.t()
+  def chroot_base, do: Path.join(work_dir(), "jails")
+
+  @doc "Node-downloaded binaries (`<work_dir>/redist`)."
+  @spec redist_dir :: Path.t()
+  def redist_dir, do: Path.join(work_dir(), "redist")
+
+  @doc "Where guest kernels install (`<work_dir>/redist/vmlinux`)."
+  @spec vmlinux_install_dir :: Path.t()
+  def vmlinux_install_dir, do: Path.join(redist_dir(), "vmlinux")
+
+  @doc "Where the default umoci installs (`<work_dir>/redist/umoci`)."
+  @spec umoci_install_dir :: Path.t()
+  def umoci_install_dir, do: Path.join(redist_dir(), "umoci")
+
+  @doc "Where a node-downloaded firecracker installs (`<work_dir>/redist/firecracker`)."
+  @spec firecracker_install_dir :: Path.t()
+  def firecracker_install_dir, do: Path.join(redist_dir(), "firecracker")
+end

lib/hyper/img.ex

@@ -6,7 +6,7 @@ defmodule Hyper.Img do
   `create/2` ingests a prepared image file -- e.g. the ext4 rootfs produced by
   `Hyper.Img.OciLoader` -- into the shared media store and the image database. It
   content-addresses the file (sha256 of its bytes = the image id), publishes it
-  into `Hyper.Config.layer_dir/0` at `layer_<id>.img`, then records it as a
+  into `Hyper.Cfg.Dirs.layer_dir/0` at `layer_<id>.img`, then records it as a
   one-layer base image (`blobs` + `images` + `image_layers`). Producers of image
   files stay decoupled from the store and DB: they hand a path to `create/2`.
   """
@@ -15,7 +15,6 @@ defmodule Hyper.Img do
 
   require Logger
 
-  alias Hyper.Config
   alias Hyper.Img.Db.{Blob, Image, ImageLayer, Repo}
 
   @type id :: String.t()
@@ -85,7 +84,7 @@ defmodule Hyper.Img do
   @spec publish(Path.t(), id()) :: {:ok, Path.t(), :created | :reused} | {:error, term()}
   @decorate with_span("Hyper.Img.publish", include: [:id])
   defp publish(src, id) do
-    File.mkdir_p!(Config.layer_dir())
+    File.mkdir_p!(Hyper.Cfg.Dirs.layer_dir())
     final = final_path(id)
 
     if File.exists?(final) do
@@ -125,7 +124,7 @@ defmodule Hyper.Img do
   end
 
   @spec final_path(id()) :: Path.t()
-  defp final_path(id), do: Path.join(Config.layer_dir(), "layer_#{id}.img")
+  defp final_path(id), do: Path.join(Hyper.Cfg.Dirs.layer_dir(), "layer_#{id}.img")
 
   # Record the base image: one blob, one image (id == blob id), one layer at
   # position 0. All upserts are idempotent so a re-publish of the same bytes is a

lib/hyper/img/oci_loader.ex

@@ -20,7 +20,6 @@ defmodule Hyper.Img.OciLoader do
 
   use Unit.Operators
 
-  alias Hyper.Config
   alias Hyper.Img.OciLoader.Umoci
   alias Unit.Information
 
@@ -185,8 +184,8 @@ defmodule Hyper.Img.OciLoader do
           {:ok, Path.t()} | {:error, term()}
   defp build_ext4(rootfs, {size, inodes}) do
     Logger.debug("oci: building #{Information.as_mib(size)} MiB ext4 rootfs (#{inodes} inodes)")
-    File.mkdir_p!(Config.layer_dir())
-    staged = Path.join(Config.layer_dir(), ".incoming-#{System.unique_integer([:positive])}.img")
+    File.mkdir_p!(Hyper.Cfg.Dirs.layer_dir())
+    staged = Path.join(Hyper.Cfg.Dirs.layer_dir(), ".incoming-#{System.unique_integer([:positive])}.img")
 
     args =
       ["-t", "ext4", "-F", "-q", "-N", to_string(inodes), "-d", rootfs, staged] ++

lib/hyper/img/oci_loader/umoci.ex

@@ -6,14 +6,12 @@ defmodule Hyper.Img.OciLoader.Umoci do
   Two sources, in priority order (mirrors `Hyper.Node.Vmlinux`):
 
     1. An operator-configured path via `[tools] umoci` in
-       `/etc/hyper/config.toml` (`Hyper.Config.umoci_path/0`). If set, it wins
+       `/etc/hyper/config.toml` (`Hyper.Cfg.Tools.umoci/0`). If set, it wins
        and is never downloaded.
     2. Otherwise the pinned static binary downloaded by `ensure_installed/0`
-       into `Hyper.Config.umoci_install_dir/0` (`<work_dir>/redist/umoci`).
+       into `Hyper.Cfg.Dirs.umoci_install_dir/0` (`<work_dir>/redist/umoci`).
   """
 
-  alias Hyper.Config
-
   require Logger
 
   # Pinned umoci release per architecture: the static binary's filename, its
@@ -69,7 +67,7 @@ defmodule Hyper.Img.OciLoader.Umoci do
 
   @spec default_path(Sys.Arch.t()) :: Path.t()
   defp default_path(arch) do
-    Path.join(Config.umoci_install_dir(), Map.fetch!(@downloads, arch).asset)
+    Path.join(Hyper.Cfg.Dirs.umoci_install_dir(), Map.fetch!(@downloads, arch).asset)
   end
 
   @spec install(Sys.Arch.t(), Path.t()) :: :ok | {:error, term()}

lib/hyper/node.ex

@@ -160,10 +160,10 @@ defmodule Hyper.Node do
   @spec check_helper_base(Path.t()) ::
           :ok | {:error, {:suid_helper_base_mismatch, Path.t(), Path.t()}}
   defp check_helper_base(base) do
-    if base == Hyper.Config.work_dir() do
+    if base == Hyper.Cfg.Dirs.work_dir() do
       :ok
     else
-      {:error, {:suid_helper_base_mismatch, base, Hyper.Config.work_dir()}}
+      {:error, {:suid_helper_base_mismatch, base, Hyper.Cfg.Dirs.work_dir()}}
     end
   end
 

lib/hyper/node/fire_vmm/jailer.ex

@@ -79,7 +79,7 @@ defmodule Hyper.Node.FireVMM.Jailer do
     end
 
     defp chroot_writable do
-      case Sys.Posix.ensure_writable_dir(Config.chroot_base()) do
+      case Sys.Posix.ensure_writable_dir(Hyper.Cfg.Dirs.chroot_base()) do
         {:ok} -> :ok
         {:error, reason} -> {:error, {:chroot_base_unavailable, reason}}
       end
@@ -104,7 +104,7 @@ defmodule Hyper.Node.FireVMM.Jailer do
         "--gid",
         to_string(opts.gid),
         "--chroot-base-dir",
-        Hyper.Config.chroot_base(),
+        Hyper.Cfg.Dirs.chroot_base(),
         "--cgroup-version",
         "2",
         "--parent-cgroup",
@@ -129,7 +129,7 @@ defmodule Hyper.Node.FireVMM.Jailer do
   @doc "Host path of the VM's per-VM jail dir (`<chroot_base>/<exec>/<id>`)."
   @spec chroot_dir(Hyper.Vm.id()) :: Path.t()
   def chroot_dir(id) do
-    Path.join([Hyper.Config.chroot_base(), exec_name(), id])
+    Path.join([Hyper.Cfg.Dirs.chroot_base(), exec_name(), id])
   end
 
   @doc "Host path of the VM's chroot root (`<chroot_base>/<exec>/<id>/root`)."
@@ -158,7 +158,7 @@ defmodule Hyper.Node.FireVMM.Jailer do
   @spec host_socket(Hyper.Vm.id()) :: Path.t()
   def host_socket(id) do
     Path.join([
-      Hyper.Config.chroot_base(),
+      Hyper.Cfg.Dirs.chroot_base(),
       exec_name(),
       id,
       "root",

lib/hyper/node/fire_vmm/provider.ex

@@ -1,7 +1,7 @@
 defmodule Hyper.Node.FireVMM.Provider do
   @moduledoc """
   Installs the firecracker release for the current architecture into
-  `Hyper.Config.firecracker_install_dir/0` (`<work_dir>/redist/firecracker`).
+  `Hyper.Cfg.Dirs.firecracker_install_dir/0` (`<work_dir>/redist/firecracker`).
 
   `ensure_installed/0` is idempotent: if the binaries are already present and
   executable it returns `:ok` without touching the network. Otherwise it fetches
@@ -88,5 +88,5 @@ defmodule Hyper.Node.FireVMM.Provider do
     Path.join(install_dir(), Map.fetch!(dl, key))
   end
 
-  defp install_dir, do: Hyper.Config.firecracker_install_dir()
+  defp install_dir, do: Hyper.Cfg.Dirs.firecracker_install_dir()
 end

lib/hyper/node/fire_vmm/vm_linux/provider.ex

@@ -1,7 +1,7 @@
 defmodule Hyper.Node.FireVMM.VmLinux.Provider do
   @moduledoc """
   Installs the guest-kernel (vmlinux) images for the current architecture into
-  `Hyper.Config.vmlinux_install_dir/0` (`<work_dir>/redist/vmlinux`).
+  `Hyper.Cfg.Dirs.vmlinux_install_dir/0` (`<work_dir>/redist/vmlinux`).
 
   The available kernels and their SHA-256 sums come from the statically-embedded
   `Hyper.Node.FireVMM.VmLinux.Manifest`. `ensure_installed/0` installs *every*
@@ -89,5 +89,5 @@ defmodule Hyper.Node.FireVMM.VmLinux.Provider do
 
   defp build_path(dir, build), do: Path.join(dir, build.asset)
 
-  defp install_dir, do: Hyper.Config.vmlinux_install_dir()
+  defp install_dir, do: Hyper.Cfg.Dirs.vmlinux_install_dir()
 end

lib/hyper/node/img/thin_pool.ex

@@ -50,7 +50,7 @@ defmodule Hyper.Node.Img.ThinPool do
   def init(_opts) do
     Process.flag(:trap_exit, true)
 
-    with :ok <- File.mkdir_p(Hyper.Config.scratch_dir()),
+    with :ok <- File.mkdir_p(Hyper.Cfg.Dirs.scratch_dir()),
          {:ok, meta} <- ensure_backing(@meta_file, ImgConfig.thin_pool_meta_size()),
          {:ok, data} <- ensure_backing(@data_file, ImgConfig.thin_pool_data_size()),
          :ok <- zero_metadata(meta),
@@ -114,7 +114,7 @@ defmodule Hyper.Node.Img.ThinPool do
   # Create a sparse file of `size` if absent; reuse it if already present.
   @spec ensure_backing(String.t(), Information.t()) :: {:ok, Path.t()} | {:error, term()}
   defp ensure_backing(file, size) do
-    path = Path.join(Hyper.Config.scratch_dir(), file)
+    path = Path.join(Hyper.Cfg.Dirs.scratch_dir(), file)
 
     case File.open(path, [:write, :read]) do
       {:ok, io} ->

lib/hyper/node/layer/repo.ex

@@ -15,8 +15,8 @@ defmodule Hyper.Node.Layer.Repo do
   @decorate with_span("Hyper.Node.Layer.Repo.test_system")
   def test_system do
     cond do
-      not File.exists?(Hyper.Config.layer_dir()) -> {:error, :layer_dir_not_found}
-      not File.dir?(Hyper.Config.layer_dir()) -> {:error, :layer_dir_not_dir}
+      not File.exists?(Hyper.Cfg.Dirs.layer_dir()) -> {:error, :layer_dir_not_found}
+      not File.dir?(Hyper.Cfg.Dirs.layer_dir()) -> {:error, :layer_dir_not_dir}
       true -> :ok
     end
   end
@@ -25,7 +25,7 @@ defmodule Hyper.Node.Layer.Repo do
   @spec find_layer(Hyper.Layer.id()) :: {:ok, Path.t()} | {:error, File.posix()}
   @decorate with_span("Hyper.Node.Layer.Repo.find_layer")
   def find_layer(id) do
-    path = Path.join([Hyper.Config.layer_dir(), layer_basename(id)])
+    path = Path.join([Hyper.Cfg.Dirs.layer_dir(), layer_basename(id)])
 
     case File.stat(path) do
       {:ok, _stat} -> {:ok, path}