mirror of
https://github.com/nix-community/home-manager.git
synced 2026-01-12 01:59:37 +08:00
602 lines
18 KiB
Nix
602 lines
18 KiB
Nix
{
|
||
config,
|
||
lib,
|
||
pkgs,
|
||
...
|
||
}:
|
||
|
||
let
|
||
|
||
cfg = config.systemd.user;
|
||
|
||
inherit (lib)
|
||
any
|
||
attrValues
|
||
filterAttrs
|
||
hm
|
||
isBool
|
||
literalExpression
|
||
mapAttrs
|
||
mkEnableOption
|
||
mkIf
|
||
mkMerge
|
||
mkOption
|
||
types
|
||
;
|
||
|
||
settingsFormat = pkgs.formats.ini { listsAsDuplicateKeys = true; };
|
||
|
||
# From <nixpkgs/nixos/modules/system/boot/systemd-lib.nix>
|
||
mkPathSafeName = lib.replaceStrings [ "@" ":" "\\" "[" "]" ] [ "-" "-" "-" "" "" ];
|
||
|
||
removeIfEmpty =
|
||
attrs: names: filterAttrs (name: value: !(builtins.elem name names) || value != "") attrs;
|
||
|
||
toSystemdIni = lib.generators.toINI {
|
||
listsAsDuplicateKeys = true;
|
||
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
|
||
filename = "${name}.${style}";
|
||
pathSafeName = mkPathSafeName filename;
|
||
|
||
# The actual unit content (or unit override content if a base is
|
||
# specified).
|
||
finalConfig =
|
||
let
|
||
# Filters out fields that are set to `null` or empty list. Also
|
||
# make sure the `Unit.X-Base` field is skipped.
|
||
shouldKeepField =
|
||
section: key: value:
|
||
value != null && value != [ ] && !(section == "Unit" && key == "X-Base");
|
||
|
||
# Filters out empty sections.
|
||
shouldKeepSection = _: value: value != { };
|
||
|
||
filteredFields = mapAttrs (section: filterAttrs (shouldKeepField section)) serviceCfg;
|
||
filteredSections = filterAttrs shouldKeepSection filteredFields;
|
||
in
|
||
filteredSections;
|
||
|
||
finalConfigIni = toSystemdIni finalConfig;
|
||
|
||
# Needed because systemd derives unit names from the ultimate
|
||
# link target.
|
||
generatedSource =
|
||
pkgs.writeTextFile {
|
||
name = pathSafeName;
|
||
text = finalConfigIni;
|
||
destination = "/${filename}";
|
||
}
|
||
+ "/${filename}";
|
||
|
||
hasBaseSource = serviceCfg.Unit.X-Base != null;
|
||
|
||
source = if hasBaseSource then serviceCfg.Unit.X-Base else generatedSource;
|
||
|
||
install = variant: target: {
|
||
name = "systemd/user/${target}.${variant}/${filename}";
|
||
value = { inherit source; };
|
||
};
|
||
in
|
||
[
|
||
{
|
||
name = "systemd/user/${filename}";
|
||
value = { inherit source; };
|
||
}
|
||
# Produce the overrides file if the main unit file is produced by X-Base.
|
||
# Note, we always create an overrides file even if no overrides are
|
||
# present. This simplifies the implementation somewhat as we don't have to
|
||
# check whether the unit settings attribute set is empty. The check would
|
||
# force the attribute set which may cause infinite recursion if it
|
||
# contains references to `config`.
|
||
{
|
||
name = "systemd/user/${filename}.d/overrides.conf";
|
||
value = lib.mkIf hasBaseSource {
|
||
source = generatedSource;
|
||
};
|
||
}
|
||
]
|
||
++ map (install "wants") (serviceCfg.Install.WantedBy or [ ])
|
||
++ map (install "requires") (serviceCfg.Install.RequiredBy or [ ]);
|
||
|
||
buildServices =
|
||
style: serviceCfgs: lib.concatLists (lib.mapAttrsToList (buildService style) serviceCfgs);
|
||
|
||
servicesStartTimeoutMs = toString cfg.servicesStartTimeoutMs;
|
||
|
||
unitBaseType =
|
||
unitKind: mod:
|
||
types.submodule {
|
||
freeformType =
|
||
with types;
|
||
let
|
||
primitive = oneOf [
|
||
bool
|
||
int
|
||
str
|
||
path
|
||
];
|
||
in
|
||
attrsOf (attrsOf (either primitive (listOf primitive)))
|
||
// {
|
||
description = "systemd ${unitKind} unit configuration";
|
||
};
|
||
|
||
imports = [
|
||
{
|
||
options.Unit = {
|
||
X-Base = mkOption {
|
||
type = types.nullOr types.path;
|
||
default = null;
|
||
example = literalExpression "\${pkgs.example}/share/systemd/user/example.service";
|
||
description = ''
|
||
::: {.warning}
|
||
This is an experimental option, it may be removed or its
|
||
behavior changed at any time!
|
||
:::
|
||
|
||
Path to unit file that should be used as a base definition. This
|
||
unit file will be copied to the Nix store (if not already there)
|
||
and linked into the user's environment. Any other fields
|
||
specified for this unit will be placed in an overrides file.
|
||
|
||
The `Unit.X-Base` field is filtered out from when the output
|
||
files are generated.
|
||
|
||
The filename of the base unit file _must_ be the same as the
|
||
unit name. That is, if you specify a base file for
|
||
`systemd.user.services."foo"`, then the base file must be
|
||
`foo.service`.
|
||
|
||
As a specific example, consider the following configuration:
|
||
|
||
``` nix
|
||
systemd.user.services.example = {
|
||
Unit.X-Base = "''${pkgs.example}/share/systemd/user/example.service";
|
||
Service.ExecStartPre = "''${pkgs.coreutils}/bin/sleep 1m"
|
||
};
|
||
```
|
||
|
||
After activation the user will have two new managed files in
|
||
their home directory:
|
||
|
||
`.config/systemd/user/example.service`
|
||
: This will point to the `X-Base` file.
|
||
|
||
`.config/systemd/user/example.service.d/overrides.conf`
|
||
: This will contain the specified overrides, in this case
|
||
``` ini
|
||
[Service]
|
||
ExecStartPre=/nix/store/...-coreutils/bin/sleep 1m
|
||
```
|
||
'';
|
||
};
|
||
|
||
Description = mkOption {
|
||
type = types.nullOr types.str;
|
||
default = null;
|
||
example = "My daily database backup";
|
||
description = "A short human-readable label of the unit.";
|
||
};
|
||
|
||
Documentation = mkOption {
|
||
type = with types; coercedTo str lib.toList (listOf str);
|
||
example = [ "my-${unitKind}.${unitKind}" ];
|
||
default = [ ];
|
||
description = "List of URIs referencing documentation for the unit.";
|
||
};
|
||
};
|
||
}
|
||
|
||
mod
|
||
];
|
||
};
|
||
|
||
unitType = unitKind: types.attrsOf (unitBaseType unitKind { });
|
||
|
||
serviceType = types.attrsOf (
|
||
unitBaseType "service" {
|
||
options = {
|
||
Unit = {
|
||
X-Reload-Triggers = mkOption {
|
||
type = with types; listOf (either package str);
|
||
default = [ ];
|
||
example = literalExpression ''[ config.xdg.configFile."service.conf".source ]'';
|
||
description = ''
|
||
List of free form strings that can be used to trigger a service
|
||
reload during Home Manager activation.
|
||
'';
|
||
};
|
||
|
||
X-Restart-Triggers = mkOption {
|
||
type = with types; listOf (either package str);
|
||
default = [ ];
|
||
example = literalExpression ''[ config.xdg.configFile."service.conf".source ]'';
|
||
description = ''
|
||
List of free form strings that can be used to trigger a service
|
||
restart during Home Manager activation.
|
||
'';
|
||
};
|
||
|
||
X-SwitchMethod = mkOption {
|
||
type = types.enum [
|
||
null
|
||
"reload"
|
||
"restart"
|
||
"stop-start"
|
||
"keep-old"
|
||
];
|
||
default = null;
|
||
example = literalExpression ''[ "''${config.xdg.configFile."service.conf".source}" ]'';
|
||
description = ''
|
||
The preferred method to use when switching from an old to a new
|
||
version of this service.
|
||
'';
|
||
};
|
||
};
|
||
|
||
Service = {
|
||
Environment = mkOption {
|
||
type = with types; coercedTo str lib.toList (listOf str);
|
||
default = [ ];
|
||
example = [
|
||
"VAR1=foo"
|
||
"VAR2=\"bar baz\""
|
||
];
|
||
description = "Environment variables available to executed processes.";
|
||
};
|
||
|
||
ExecStart = mkOption {
|
||
type =
|
||
with types;
|
||
let
|
||
primitive = either package str;
|
||
in
|
||
either primitive (listOf primitive);
|
||
apply = lib.toList;
|
||
default = [ ];
|
||
example = "/absolute/path/to/command arg1 arg2";
|
||
description = "Command that is executed when this service is started.";
|
||
};
|
||
};
|
||
};
|
||
}
|
||
);
|
||
|
||
unitDescription = type: ''
|
||
Definition of systemd per-user ${type} units. Attributes are
|
||
merged recursively.
|
||
|
||
Note that the attributes follow the capitalization and naming used
|
||
by systemd. More details can be found in
|
||
{manpage}`systemd.${type}(5)`.
|
||
'';
|
||
|
||
unitExample =
|
||
type:
|
||
literalExpression ''
|
||
{
|
||
${lib.toLower type}-name = {
|
||
Unit = {
|
||
Description = "Example description";
|
||
Documentation = [ "man:example(1)" "man:example(5)" ];
|
||
};
|
||
|
||
${type} = {
|
||
…
|
||
};
|
||
};
|
||
};
|
||
'';
|
||
|
||
sessionVariables = mkIf (cfg.sessionVariables != { }) {
|
||
"environment.d/10-home-manager.conf".text =
|
||
lib.concatStringsSep "\n" (lib.mapAttrsToList (n: v: "${n}=${toString v}") cfg.sessionVariables)
|
||
+ "\n";
|
||
};
|
||
|
||
settings = mkIf (any (v: v != { }) (attrValues cfg.settings)) {
|
||
"systemd/user.conf".source = settingsFormat.generate "user.conf" cfg.settings;
|
||
};
|
||
|
||
configHome = lib.removePrefix config.home.homeDirectory config.xdg.configHome;
|
||
|
||
in
|
||
{
|
||
meta.maintainers = [ lib.maintainers.rycee ];
|
||
|
||
options = {
|
||
systemd.user = {
|
||
enable = mkEnableOption "the user systemd service manager" // {
|
||
default = pkgs.stdenv.isLinux;
|
||
defaultText = literalExpression "pkgs.stdenv.isLinux";
|
||
};
|
||
|
||
systemctlPath = mkOption {
|
||
default = "${pkgs.systemd}/bin/systemctl";
|
||
defaultText = literalExpression ''"''${pkgs.systemd}/bin/systemctl"'';
|
||
type = types.str;
|
||
description = ''
|
||
Absolute path to the {command}`systemctl` tool. This
|
||
option may need to be set if running Home Manager on a
|
||
non-NixOS distribution.
|
||
'';
|
||
};
|
||
|
||
services = mkOption {
|
||
default = { };
|
||
type = serviceType;
|
||
description = (unitDescription "service");
|
||
example = unitExample "Service";
|
||
};
|
||
|
||
slices = mkOption {
|
||
default = { };
|
||
type = unitType "slice";
|
||
description = (unitDescription "slice");
|
||
example = unitExample "Slice";
|
||
};
|
||
|
||
sockets = mkOption {
|
||
default = { };
|
||
type = unitType "socket";
|
||
description = (unitDescription "socket");
|
||
example = unitExample "Socket";
|
||
};
|
||
|
||
targets = mkOption {
|
||
default = { };
|
||
type = unitType "target";
|
||
description = (unitDescription "target");
|
||
example = unitExample "Target";
|
||
};
|
||
|
||
timers = mkOption {
|
||
default = { };
|
||
type = unitType "timer";
|
||
description = (unitDescription "timer");
|
||
example = unitExample "Timer";
|
||
};
|
||
|
||
paths = mkOption {
|
||
default = { };
|
||
type = unitType "path";
|
||
description = (unitDescription "path");
|
||
example = unitExample "Path";
|
||
};
|
||
|
||
mounts = mkOption {
|
||
default = { };
|
||
type = unitType "mount";
|
||
description = (unitDescription "mount");
|
||
example = unitExample "Mount";
|
||
};
|
||
|
||
automounts = mkOption {
|
||
default = { };
|
||
type = unitType "automount";
|
||
description = (unitDescription "automount");
|
||
example = unitExample "Automount";
|
||
};
|
||
|
||
startServices = mkOption {
|
||
type =
|
||
with types;
|
||
either bool (enum [
|
||
"suggest"
|
||
"sd-switch"
|
||
]);
|
||
apply = p: if isBool p then p else p == "sd-switch";
|
||
default = true;
|
||
description = ''
|
||
Whether new or changed services that are wanted by active targets
|
||
should be started. Additionally, stop obsolete services from the
|
||
previous generation.
|
||
|
||
The alternatives are
|
||
|
||
`suggest` (or `false`)
|
||
: Use a very simple shell script to print suggested
|
||
{command}`systemctl` commands to run. You will have to
|
||
manually run those commands after the switch.
|
||
|
||
`sd-switch` (or `true`)
|
||
: Use sd-switch, a tool that determines the necessary changes and
|
||
automatically apply them.
|
||
'';
|
||
};
|
||
|
||
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
|
||
{manpage}`environment.d(5)`.
|
||
'';
|
||
};
|
||
|
||
settings = mkOption {
|
||
apply =
|
||
sections:
|
||
sections
|
||
// {
|
||
# Setting one of these to an empty value would reset any
|
||
# previous settings, so we’ll remove them instead if they
|
||
# are not explicitly set.
|
||
Manager = removeIfEmpty sections.Manager [
|
||
"ManagerEnvironment"
|
||
"DefaultEnvironment"
|
||
];
|
||
};
|
||
|
||
type = types.submodule {
|
||
freeformType = settingsFormat.type;
|
||
|
||
options =
|
||
let
|
||
inherit (lib) concatStringsSep escapeShellArg mapAttrsToList;
|
||
environmentOption =
|
||
args:
|
||
mkOption {
|
||
type =
|
||
with types;
|
||
attrsOf (
|
||
nullOr (oneOf [
|
||
str
|
||
path
|
||
package
|
||
])
|
||
);
|
||
default = { };
|
||
example = literalExpression ''
|
||
{
|
||
PATH = "%u/bin:%u/.cargo/bin";
|
||
}
|
||
'';
|
||
apply = value: concatStringsSep " " (mapAttrsToList (n: v: "${n}=${escapeShellArg v}") value);
|
||
}
|
||
// args;
|
||
in
|
||
{
|
||
Manager = {
|
||
DefaultEnvironment = environmentOption {
|
||
description = ''
|
||
Configures environment variables passed to all executed processes.
|
||
'';
|
||
};
|
||
ManagerEnvironment = environmentOption {
|
||
description = ''
|
||
Sets environment variables just for the manager process itself.
|
||
'';
|
||
};
|
||
};
|
||
};
|
||
};
|
||
default = { };
|
||
example = literalExpression ''
|
||
{
|
||
Manager.DefaultCPUAccounting = true;
|
||
}
|
||
'';
|
||
description = ''
|
||
Extra config options for user session service manager. See {manpage}`systemd-user.conf(5)` for
|
||
available options.
|
||
'';
|
||
};
|
||
};
|
||
};
|
||
|
||
# If we run under a Linux system we assume that systemd is
|
||
# available, in particular we assume that systemctl is in PATH.
|
||
# Do not install any user services if username is root.
|
||
config = mkIf (cfg.enable && config.home.username != "root") {
|
||
assertions = [
|
||
(lib.hm.assertions.assertPlatform "systemd" pkgs lib.platforms.linux)
|
||
];
|
||
|
||
xdg.configFile = mkMerge [
|
||
(lib.listToAttrs (
|
||
(buildServices "service" cfg.services)
|
||
++ (buildServices "slice" cfg.slices)
|
||
++ (buildServices "socket" cfg.sockets)
|
||
++ (buildServices "target" cfg.targets)
|
||
++ (buildServices "timer" cfg.timers)
|
||
++ (buildServices "path" cfg.paths)
|
||
++ (buildServices "mount" cfg.mounts)
|
||
++ (buildServices "automount" cfg.automounts)
|
||
))
|
||
|
||
sessionVariables
|
||
|
||
settings
|
||
];
|
||
|
||
# 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
|
||
suggestCmd = ''
|
||
bash ${./systemd-activate.sh} "''${oldGenPath=}" "$newGenPath"
|
||
'';
|
||
|
||
sdSwitchCmd =
|
||
let
|
||
timeoutArg = if cfg.servicesStartTimeoutMs != 0 then "--timeout " + servicesStartTimeoutMs else "";
|
||
in
|
||
''
|
||
${lib.getExe pkgs.sd-switch} \
|
||
''${DRY_RUN:+--dry-run} $VERBOSE_ARG ${timeoutArg} \
|
||
''${oldUnitsDir:+--old-units $oldUnitsDir} \
|
||
--new-units "$newUnitsDir"
|
||
'';
|
||
|
||
systemdCmd = if cfg.startServices then sdSwitchCmd else suggestCmd;
|
||
|
||
# Make sure that we have an environment where we are likely to
|
||
# successfully talk with systemd.
|
||
ensureSystemd = ''
|
||
env XDG_RUNTIME_DIR="''${XDG_RUNTIME_DIR:-/run/user/$(id -u)}" \
|
||
PATH="${dirOf cfg.systemctlPath}:$PATH" \
|
||
'';
|
||
|
||
systemctl = "${ensureSystemd} systemctl";
|
||
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
|
||
|
||
if [[ -v oldGenPath ]]; then
|
||
oldUnitsDir="$oldGenPath/home-files${configHome}/systemd/user"
|
||
if [[ ! -e $oldUnitsDir ]]; then
|
||
oldUnitsDir=
|
||
fi
|
||
fi
|
||
|
||
newUnitsDir="$newGenPath/home-files${configHome}/systemd/user"
|
||
if [[ ! -e $newUnitsDir ]]; then
|
||
newUnitsDir=${pkgs.emptyDirectory}
|
||
fi
|
||
|
||
${ensureSystemd} ${systemdCmd}
|
||
|
||
unset newUnitsDir oldUnitsDir
|
||
else
|
||
echo "User systemd daemon not running. Skipping reload."
|
||
fi
|
||
|
||
unset systemdStatus
|
||
''
|
||
);
|
||
};
|
||
}
|