home-manager/modules/systemd.nix

350 lines
11 KiB
Nix
Raw Normal View History

2017-01-07 19:16:26 +01:00
{ config, lib, pkgs, ... }:
let
cfg = config.systemd.user;
inherit (lib) getAttr hm isBool literalExample mkIf mkMerge mkOption types;
# From <nixpkgs/nixos/modules/system/boot/systemd-lib.nix>
mkPathSafeName = lib.replaceChars ["@" ":" "\\" "[" "]"] ["-" "-" "-" "" ""];
2017-06-29 01:06:08 +02:00
enabled = cfg.services != {}
2020-12-04 14:14:24 +01:00
|| cfg.slices != {}
2017-06-29 01:06:08 +02:00
|| cfg.sockets != {}
|| cfg.targets != {}
2018-06-29 12:14:35 +02:00
|| cfg.timers != {}
|| cfg.paths != {}
2020-11-27 21:29:44 +01:00
|| cfg.mounts != {}
2019-10-29 03:29:12 +01:00
|| cfg.automounts != {}
|| cfg.sessionVariables != {};
toSystemdIni = lib.generators.toINI {
listsAsDuplicateKeys = true;
2017-01-07 19:16:26 +01:00
mkKeyValue = key: value:
let
value' =
if isBool value then (if value then "true" else "false")
else toString value;
in
"${key}=${value'}";
};
buildService = style: name: serviceCfg:
let
2017-12-02 22:52:35 +01:00
filename = "${name}.${style}";
pathSafeName = mkPathSafeName filename;
2017-12-02 22:52:35 +01:00
# Needed because systemd derives unit names from the ultimate
# link target.
source = pkgs.writeTextFile {
name = pathSafeName;
text = toSystemdIni serviceCfg;
destination = lib.escapeShellArg "/${filename}";
} + "/${filename}";
2017-01-07 19:16:26 +01:00
wantedBy = target:
{
2017-12-02 22:52:35 +01:00
name = "systemd/user/${target}.wants/${filename}";
value = { inherit source; };
2017-01-07 19:16:26 +01:00
};
in
lib.singleton {
2017-12-02 22:52:35 +01:00
name = "systemd/user/${filename}";
value = { inherit source; };
2017-01-07 19:16:26 +01:00
}
++
map wantedBy (serviceCfg.Install.WantedBy or []);
buildServices = style: serviceCfgs:
lib.concatLists (lib.mapAttrsToList (buildService style) serviceCfgs);
2017-01-07 19:16:26 +01:00
servicesStartTimeoutMs = builtins.toString cfg.servicesStartTimeoutMs;
unitType = unitKind: with types;
let
primitive = either bool (either int str);
in
attrsOf (attrsOf (attrsOf (either primitive (listOf primitive))))
// {
description = "systemd ${unitKind} unit configuration";
};
unitDescription = type: ''
Definition of systemd per-user ${type} units. Attributes are
merged recursively.
</para><para>
Note that the attributes follow the capitalization and naming used
by systemd. More details can be found in
<citerefentry>
<refentrytitle>systemd.${type}</refentrytitle>
<manvolnum>5</manvolnum>
</citerefentry>.
'';
unitExample = type: literalExample ''
{
${lib.toLower type}-name = {
2019-08-29 19:12:39 +02:00
Unit = {
Description = "Example description";
Documentation = [ "man:example(1)" "man:example(5)" ];
};
2019-08-29 19:12:39 +02:00
${type} = {
};
};
2019-08-29 19:12:39 +02:00
};
'';
sessionVariables = mkIf (cfg.sessionVariables != {}) {
"environment.d/10-home-manager.conf".text =
lib.concatStringsSep "\n" (
lib.mapAttrsToList (n: v: "${n}=${toString v}") cfg.sessionVariables
) + "\n";
};
2017-01-07 19:16:26 +01:00
in
{
meta.maintainers = [ lib.maintainers.rycee ];
2017-01-07 19:16:26 +01:00
options = {
systemd.user = {
systemctlPath = mkOption {
default = "${pkgs.systemd}/bin/systemctl";
defaultText = "\${pkgs.systemd}/bin/systemctl";
type = types.str;
description = ''
Absolute path to the <command>systemctl</command> tool. This
option may need to be set if running Home Manager on a
non-NixOS distribution.
'';
};
2017-01-07 19:16:26 +01:00
services = mkOption {
default = {};
type = unitType "service";
description = unitDescription "service";
example = unitExample "Service";
2017-01-07 19:16:26 +01:00
};
2020-12-04 14:14:24 +01:00
slices = mkOption {
default = {};
type = unitType "slices";
description = unitDescription "slices";
example = unitExample "Slices";
};
2017-06-29 01:06:08 +02:00
sockets = mkOption {
default = {};
type = unitType "socket";
description = unitDescription "socket";
example = unitExample "Socket";
2017-06-29 01:06:08 +02:00
};
targets = mkOption {
default = {};
type = unitType "target";
description = unitDescription "target";
example = unitExample "Target";
};
2017-01-07 19:16:26 +01:00
timers = mkOption {
default = {};
type = unitType "timer";
description = unitDescription "timer";
example = unitExample "Timer";
2017-01-07 19:16:26 +01:00
};
2018-06-29 12:14:35 +02:00
paths = mkOption {
default = {};
type = unitType "path";
description = unitDescription "path";
example = unitExample "Path";
2018-06-29 12:14:35 +02:00
};
2020-11-27 21:29:44 +01:00
mounts = mkOption {
default = {};
type = unitType "mount";
description = unitDescription "mount";
example = unitExample "Mount";
};
2019-10-29 03:29:12 +01:00
automounts = mkOption {
default = {};
type = unitType "automount";
description = unitDescription "automount";
example = unitExample "Automount";
};
startServices = mkOption {
default = "suggest";
type = with types; either bool (enum ["suggest" "legacy" "sd-switch"]);
apply = p:
if isBool p then if p then "legacy" else "suggest"
else p;
description = ''
Whether new or changed services that are wanted by active targets
should be started. Additionally, stop obsolete services from the
previous generation.
</para><para>
The alternatives are
<variablelist>
<varlistentry>
<term><literal>suggest</literal> (or <literal>false</literal>)</term>
<listitem><para>
Use a very simple shell script to print suggested
<command>systemctl</command> commands to run. You will have to
manually run those commands after the switch.
</para></listitem>
</varlistentry>
<varlistentry>
<term><literal>legacy</literal> (or <literal>true</literal>)</term>
<listitem><para>
Use a Ruby script to, in a more robust fashion, determine the
necessary changes and automatically run the
<command>systemctl</command> commands.
</para></listitem>
</varlistentry>
<varlistentry>
<term><literal>sd-switch</literal></term>
<listitem><para>
Use sd-switch, a third party application, to perform the service
updates. This tool offers more features while having a small
closure size. Note, it requires a fully functional user D-Bus
session. Once tested and deemed sufficiently robust, this will
become the default.
</para></listitem>
</varlistentry>
</variablelist>
'';
};
servicesStartTimeoutMs = mkOption {
default = 0;
type = types.ints.unsigned;
description = ''
How long to wait for started services to fail until their start is
considered successful. The value 0 indicates no timeout.
'';
};
sessionVariables = mkOption {
default = {};
type = with types; attrsOf (either int str);
example = { EDITOR = "vim"; };
description = ''
Environment variables that will be set for the user session.
The variable values must be as described in
<citerefentry>
<refentrytitle>environment.d</refentrytitle>
<manvolnum>5</manvolnum>
</citerefentry>.
'';
};
2017-01-07 19:16:26 +01:00
};
};
config = mkMerge [
{
assertions = [
{
assertion = enabled -> pkgs.stdenv.isLinux;
message =
let
names = lib.concatStringsSep ", " (
lib.attrNames (
2020-12-04 14:14:24 +01:00
cfg.services // cfg.slices // cfg.sockets // cfg.targets
2020-11-27 21:29:44 +01:00
// cfg.timers // cfg.paths // cfg.mounts // cfg.sessionVariables
2017-06-29 01:06:08 +02:00
)
);
in
"Must use Linux for modules that require systemd: " + names;
}
];
}
# If we run under a Linux system we assume that systemd is
# available, in particular we assume that systemctl is in PATH.
(mkIf pkgs.stdenv.isLinux {
xdg.configFile = mkMerge [
(lib.listToAttrs (
(buildServices "service" cfg.services)
++
2020-12-04 14:14:24 +01:00
(buildServices "slices" cfg.slices)
++
2017-06-29 01:06:08 +02:00
(buildServices "socket" cfg.sockets)
++
(buildServices "target" cfg.targets)
++
(buildServices "timer" cfg.timers)
2018-06-29 12:14:35 +02:00
++
(buildServices "path" cfg.paths)
2020-11-27 21:29:44 +01:00
++
(buildServices "mount" cfg.mounts)
2019-10-29 03:29:12 +01:00
++
(buildServices "automount" cfg.automounts)
))
sessionVariables
];
# Run systemd service reload if user is logged in. If we're
# running this from the NixOS module then XDG_RUNTIME_DIR is not
# set and systemd commands will fail. We'll therefore have to
# set it ourselves in that case.
home.activation.reloadSystemd = hm.dag.entryAfter ["linkGeneration"] (
let
cmd = {
suggest = ''
PATH=${dirOf cfg.systemctlPath}:$PATH \
bash ${./systemd-activate.sh} "''${oldGenPath=}" "$newGenPath"
'';
legacy = ''
PATH=${dirOf cfg.systemctlPath}:$PATH \
${pkgs.ruby}/bin/ruby ${./systemd-activate.rb} \
"''${oldGenPath=}" "$newGenPath" "${servicesStartTimeoutMs}"
'';
sd-switch =
let
timeoutArg =
if cfg.servicesStartTimeoutMs != 0 then
"--timeout " + servicesStartTimeoutMs
else
"";
in ''
${pkgs.sd-switch}/bin/sd-switch \
''${DRY_RUN:+--dry-run} $VERBOSE_ARG ${timeoutArg} \
''${oldGenPath:+--old-units $oldGenPath/home-files/.config/systemd/user} \
--new-units $newGenPath/home-files/.config/systemd/user
'';
};
ensureRuntimeDir = "XDG_RUNTIME_DIR=\${XDG_RUNTIME_DIR:-/run/user/$(id -u)}";
systemctl = "${ensureRuntimeDir} ${cfg.systemctlPath}";
in
''
systemdStatus=$(${systemctl} --user is-system-running 2>&1 || true)
if [[ $systemdStatus == 'running' || $systemdStatus == 'degraded' ]]; then
if [[ $systemdStatus == 'degraded' ]]; then
warnEcho "The user systemd session is degraded:"
${systemctl} --user --no-pager --state=failed
warnEcho "Attempting to reload services anyway..."
fi
${ensureRuntimeDir} \
${getAttr cfg.startServices cmd}
else
echo "User systemd daemon not running. Skipping reload."
fi
unset systemdStatus
''
);
})
];
2017-01-07 19:16:26 +01:00
}