Expand builders and unit file D-Bus queries

Author: dannote

lib/systemd.ex

@@ -73,6 +73,22 @@ defmodule Systemd do
     end)
   end
 
+  @doc """
+  Returns unit files known to systemd using a short-lived connection.
+  """
+  @spec list_unit_files(keyword()) :: {:ok, [Systemd.UnitFileStatus.t()]} | {:error, Error.t()}
+  def list_unit_files(opts \\ []) do
+    with_connection(opts, &Manager.list_unit_files/1)
+  end
+
+  @doc """
+  Returns the enablement state of a unit file using a short-lived connection.
+  """
+  @spec unit_file_state(String.t(), keyword()) :: {:ok, String.t()} | {:error, Error.t()}
+  def unit_file_state(name, opts \\ []) do
+    with_connection(opts, &Manager.unit_file_state(&1, name))
+  end
+
   @doc """
   Starts a unit and waits for the returned job by default.
   """

lib/systemd/dbus/signature.ex

@@ -3,6 +3,7 @@ defmodule Systemd.DBus.Signature do
 
   @supported_complex_signatures MapSet.new([
                                   "a(ssssssouso)",
+                                  "a(ss)",
                                   "a{sv}",
                                   "a(sv)",
                                   "a(sa(sv))",

lib/systemd/manager.ex

@@ -3,7 +3,7 @@ defmodule Systemd.Manager do
   Client for `org.freedesktop.systemd1.Manager`.
   """
 
-  alias Systemd.{DBus, Error, Job, Unit, UnitFileOperation, UnitObject}
+  alias Systemd.{DBus, Error, Job, Unit, UnitFileOperation, UnitFileStatus, UnitObject}
   alias Systemd.Manager.Options
   alias Systemd.TransientUnit.{AuxUnit, Property}
 
@@ -47,7 +47,37 @@ defmodule Systemd.Manager do
   @spec get_unit(pid(), String.t()) :: {:ok, UnitObject.t()} | {:error, Error.t()}
   def get_unit(conn, unit_name) when is_pid(conn) and is_binary(unit_name) do
     with {:ok, [object_path]} <- call(conn, "GetUnit", [unit_name], "s") do
-      {:ok, %UnitObject{name: unit_name, object_path: object_path}}
+      {:ok, UnitObject.new(object_path, unit_name)}
+    end
+  end
+
+  @doc """
+  Gets the D-Bus object path for a unit by main process ID.
+  """
+  @spec get_unit_by_pid(pid(), non_neg_integer()) :: {:ok, UnitObject.t()} | {:error, Error.t()}
+  def get_unit_by_pid(conn, pid) when is_pid(conn) and is_integer(pid) and pid >= 0 do
+    with {:ok, [object_path]} <- call(conn, "GetUnitByPID", [pid], "u") do
+      {:ok, UnitObject.new(object_path)}
+    end
+  end
+
+  @doc """
+  Returns unit files known to systemd and their enablement state.
+  """
+  @spec list_unit_files(pid()) :: {:ok, [UnitFileStatus.t()]} | {:error, Error.t()}
+  def list_unit_files(conn) when is_pid(conn) do
+    with {:ok, [unit_files]} <- call(conn, "ListUnitFiles") do
+      {:ok, Enum.map(unit_files, &UnitFileStatus.from_dbus/1)}
+    end
+  end
+
+  @doc """
+  Returns the enablement state of a unit file.
+  """
+  @spec unit_file_state(pid(), String.t()) :: {:ok, String.t()} | {:error, Error.t()}
+  def unit_file_state(conn, unit_name) when is_pid(conn) and is_binary(unit_name) do
+    with {:ok, [state]} <- call(conn, "GetUnitFileState", [unit_name], "s") do
+      {:ok, state}
     end
   end
 

lib/systemd/unit_file.ex

@@ -20,6 +20,18 @@ defmodule Systemd.UnitFile do
   @spec service(keyword()) :: t()
   defdelegate service(opts), to: Builder
 
+  @doc """
+  Builds a socket unit file from common `Unit`, `Socket`, and `Install` sections.
+  """
+  @spec socket(keyword()) :: t()
+  defdelegate socket(opts), to: Builder
+
+  @doc """
+  Builds a timer unit file from common `Unit`, `Timer`, and `Install` sections.
+  """
+  @spec timer(keyword()) :: t()
+  defdelegate timer(opts), to: Builder
+
   @doc """
   Parses unit file text.
   """

lib/systemd/unit_file/builder.ex

@@ -8,7 +8,33 @@ defmodule Systemd.UnitFile.Builder do
   @type directives :: keyword() | %{optional(atom() | String.t()) => term()}
 
   @directive_names %{
-    limit_nofile: "LimitNOFILE"
+    cpu_accounting: "CPUAccounting",
+    io_accounting: "IOAccounting",
+    ip_accounting: "IPAccounting",
+    limit_as: "LimitAS",
+    limit_core: "LimitCORE",
+    limit_cpu: "LimitCPU",
+    limit_data: "LimitDATA",
+    limit_fsize: "LimitFSIZE",
+    limit_locks: "LimitLOCKS",
+    limit_memlock: "LimitMEMLOCK",
+    limit_msgqueue: "LimitMSGQUEUE",
+    limit_nice: "LimitNICE",
+    limit_nofile: "LimitNOFILE",
+    limit_nproc: "LimitNPROC",
+    limit_rss: "LimitRSS",
+    limit_rtprio: "LimitRTPRIO",
+    limit_rttime: "LimitRTTIME",
+    limit_sigpending: "LimitSIGPENDING",
+    oom_policy: "OOMPolicy",
+    pid_file: "PIDFile",
+    runtime_directory_preserve: "RuntimeDirectoryPreserve",
+    selinux_context: "SELinuxContext",
+    smack_process_label: "SmackProcessLabel",
+    syslog_identifier: "SyslogIdentifier",
+    tty_path: "TTYPath",
+    usb_function_descriptors: "USBFunctionDescriptors",
+    usb_function_strings: "USBFunctionStrings"
   }
 
   @doc """
@@ -22,6 +48,28 @@ defmodule Systemd.UnitFile.Builder do
     |> maybe_append_section("Install", Keyword.get(opts, :install, []))
   end
 
+  @doc """
+  Builds a socket unit file from common `Unit`, `Socket`, and `Install` sections.
+  """
+  @spec socket(keyword()) :: UnitFile.t()
+  def socket(opts) when is_list(opts) do
+    UnitFile.parse!("")
+    |> maybe_append_section("Unit", Keyword.get(opts, :unit, []))
+    |> maybe_append_section("Socket", Keyword.get(opts, :socket, []))
+    |> maybe_append_section("Install", Keyword.get(opts, :install, []))
+  end
+
+  @doc """
+  Builds a timer unit file from common `Unit`, `Timer`, and `Install` sections.
+  """
+  @spec timer(keyword()) :: UnitFile.t()
+  def timer(opts) when is_list(opts) do
+    UnitFile.parse!("")
+    |> maybe_append_section("Unit", Keyword.get(opts, :unit, []))
+    |> maybe_append_section("Timer", Keyword.get(opts, :timer, []))
+    |> maybe_append_section("Install", Keyword.get(opts, :install, []))
+  end
+
   @doc """
   Builds a unit file with one section.
   """

lib/systemd/unit_file/validator.ex

@@ -25,20 +25,20 @@ defmodule Systemd.UnitFile.Validator do
   @known_directives %{
     "Unit" =>
       MapSet.new(
-        ~w(Description Documentation Requires Wants After Before BindsTo PartOf Conflicts ConditionPathExists AssertPathExists StartLimitIntervalSec StartLimitBurst)
+        ~w(Description Documentation Requires Wants After Before BindsTo PartOf Conflicts RequiresMountsFor ConditionPathExists AssertPathExists StartLimitIntervalSec StartLimitBurst)
       ),
     "Service" =>
       MapSet.new(
-        ~w(Type ExecStart ExecStartPre ExecStartPost ExecReload ExecStop ExecStopPost Restart RestartSec User Group WorkingDirectory Environment EnvironmentFile TimeoutStartSec TimeoutStopSec KillSignal KillMode RemainAfterExit PIDFile RuntimeDirectory StateDirectory CacheDirectory LogsDirectory StandardOutput StandardError LimitNOFILE)
+        ~w(Type ExecStart ExecStartPre ExecStartPost ExecCondition ExecReload ExecStop ExecStopPost Restart RestartSec User Group WorkingDirectory RootDirectory Environment EnvironmentFile PassEnvironment UnsetEnvironment TimeoutStartSec TimeoutStopSec TimeoutAbortSec KillSignal KillMode RemainAfterExit GuessMainPID PIDFile RuntimeDirectory RuntimeDirectoryPreserve StateDirectory CacheDirectory LogsDirectory ConfigurationDirectory StandardOutput StandardError SyslogIdentifier LimitNOFILE LimitNPROC LimitMEMLOCK LimitCORE LimitCPU LimitAS LimitFSIZE NoNewPrivileges PrivateTmp PrivateDevices ProtectSystem ProtectHome AmbientCapabilities CapabilityBoundingSet ReadWritePaths ReadOnlyPaths InaccessiblePaths OOMPolicy)
       ),
     "Install" => MapSet.new(~w(WantedBy RequiredBy Also Alias DefaultInstance)),
     "Socket" =>
       MapSet.new(
-        ~w(ListenStream ListenDatagram ListenSequentialPacket SocketUser SocketGroup SocketMode Accept Service)
+        ~w(ListenStream ListenDatagram ListenSequentialPacket ListenFIFO ListenSpecial ListenNetlink ListenMessageQueue ListenUSBFunction SocketUser SocketGroup SocketMode DirectoryMode Accept Writable MaxConnections MaxConnectionsPerSource KeepAlive NoDelay FreeBind BindIPv6Only Backlog Service)
       ),
     "Timer" =>
       MapSet.new(
-        ~w(OnActiveSec OnBootSec OnStartupSec OnUnitActiveSec OnUnitInactiveSec OnCalendar Unit Persistent AccuracySec RandomizedDelaySec)
+        ~w(OnActiveSec OnBootSec OnStartupSec OnUnitActiveSec OnUnitInactiveSec OnCalendar Unit Persistent AccuracySec RandomizedDelaySec FixedRandomDelay WakeSystem RemainAfterElapse)
       ),
     "Target" => MapSet.new(~w(AllowIsolate)),
     "Mount" =>
@@ -215,10 +215,25 @@ defmodule Systemd.UnitFile.Validator do
   end
 
   defp value_errors("Service", directive, value, span)
-       when directive in ["TimeoutStartSec", "TimeoutStopSec", "RestartSec"] do
+       when directive in ["TimeoutStartSec", "TimeoutStopSec", "TimeoutAbortSec", "RestartSec"] do
     duration("Service", directive, value, span)
   end
 
+  defp value_errors("Service", directive, value, span)
+       when directive in [
+              "RemainAfterExit",
+              "GuessMainPID",
+              "NoNewPrivileges",
+              "PrivateTmp",
+              "PrivateDevices"
+            ] do
+    boolean("Service", directive, value, span)
+  end
+
+  defp value_errors("Service", "KillMode", value, span) do
+    one_of("Service", "KillMode", value, ~w(control-group mixed process none), span)
+  end
+
   defp value_errors("Timer", directive, value, span)
        when directive in [
               "OnActiveSec",
@@ -232,19 +247,37 @@ defmodule Systemd.UnitFile.Validator do
     duration("Timer", directive, value, span)
   end
 
-  defp value_errors("Timer", "Persistent", value, span),
-    do: boolean("Timer", "Persistent", value, span)
+  defp value_errors("Timer", directive, value, span)
+       when directive in ["Persistent", "FixedRandomDelay", "WakeSystem", "RemainAfterElapse"] do
+    boolean("Timer", directive, value, span)
+  end
 
   defp value_errors("Timer", "OnCalendar", value, span),
     do: non_empty("Timer", "OnCalendar", value, span)
 
   defp value_errors("Socket", directive, value, span)
-       when directive in ["ListenStream", "ListenDatagram", "ListenSequentialPacket"] do
+       when directive in [
+              "ListenStream",
+              "ListenDatagram",
+              "ListenSequentialPacket",
+              "ListenFIFO",
+              "ListenSpecial",
+              "ListenNetlink",
+              "ListenMessageQueue",
+              "ListenUSBFunction"
+            ] do
     non_empty("Socket", directive, value, span)
   end
 
-  defp value_errors("Socket", "SocketMode", value, span),
-    do: octal_mode("Socket", "SocketMode", value, span)
+  defp value_errors("Socket", directive, value, span)
+       when directive in ["SocketMode", "DirectoryMode"] do
+    octal_mode("Socket", directive, value, span)
+  end
+
+  defp value_errors("Socket", directive, value, span)
+       when directive in ["Accept", "Writable", "KeepAlive", "NoDelay", "FreeBind"] do
+    boolean("Socket", directive, value, span)
+  end
 
   defp value_errors("Install", directive, value, span)
        when directive in ["WantedBy", "RequiredBy", "Also", "Alias"] do

lib/systemd/unit_file_status.ex

@@ -0,0 +1,24 @@
+defmodule Systemd.UnitFileStatus do
+  @moduledoc """
+  Unit-file status returned by systemd's `ListUnitFiles` D-Bus method.
+  """
+
+  @enforce_keys [:path, :state]
+  @type t :: %__MODULE__{
+          path: String.t(),
+          state: String.t()
+        }
+
+  defstruct [:path, :state]
+
+  @doc false
+  @spec new(String.t(), String.t()) :: t()
+  def new(path, state) when is_binary(path) and is_binary(state) do
+    %__MODULE__{path: path, state: state}
+  end
+
+  @doc false
+  @spec from_dbus(tuple() | list()) :: t()
+  def from_dbus({path, state}), do: from_dbus([path, state])
+  def from_dbus([path, state]), do: new(path, state)
+end

test/systemd/dbus/signature_test.exs

@@ -6,6 +6,7 @@ defmodule Systemd.DBus.SignatureTest do
   test "documents signatures this package intentionally uses" do
     assert Signature.supported?("")
     assert Signature.supported?("asbb")
+    assert Signature.supported?("a(ss)")
     assert Signature.supported?("ssa(sv)a(sa(sv))")
     refute Signature.supported?("a{sa{sv}}")
   end

test/systemd/manager_integration_test.exs

@@ -1,7 +1,16 @@
 defmodule Systemd.ManagerIntegrationTest do
   use ExUnit.Case, async: false
 
-  alias Systemd.{Error, Job, Manager, TransientUnit, Unit, UnitFileOperation, UnitObject}
+  alias Systemd.{
+    Error,
+    Job,
+    Manager,
+    TransientUnit,
+    Unit,
+    UnitFileOperation,
+    UnitFileStatus,
+    UnitObject
+  }
 
   @moduletag :integration
 
@@ -13,6 +22,19 @@ defmodule Systemd.ManagerIntegrationTest do
     assert Enum.any?(units, &(&1.name == "init.scope" or &1.name == "-.slice"))
   end
 
+  test "lists unit files and reads unit-file state" do
+    assert {:ok, conn} = Manager.connect()
+
+    assert {:ok, unit_files} = Manager.list_unit_files(conn)
+
+    assert Enum.any?(unit_files, fn %UnitFileStatus{path: path, state: state} ->
+             is_binary(path) and String.ends_with?(path, ".service") and is_binary(state)
+           end)
+
+    assert {:ok, state} = Manager.unit_file_state(conn, "dbus.service")
+    assert is_binary(state)
+  end
+
   test "gets a unit object and reads common properties" do
     assert {:ok, conn} = Manager.connect()
     assert {:ok, %UnitObject{} = unit} = Manager.get_unit(conn, "dbus.service")

test/systemd/unit_file_status_test.exs

@@ -0,0 +1,13 @@
+defmodule Systemd.UnitFileStatusTest do
+  use ExUnit.Case, async: true
+
+  alias Systemd.UnitFileStatus
+
+  test "builds unit-file status from D-Bus rows" do
+    assert %UnitFileStatus{path: "dbus.service", state: "enabled"} =
+             UnitFileStatus.from_dbus(["dbus.service", "enabled"])
+
+    assert %UnitFileStatus{path: "ssh.service", state: "disabled"} =
+             UnitFileStatus.from_dbus({"ssh.service", "disabled"})
+  end
+end