{ config, pkgs, ... }:
with pkgs.lib;
let
upstart = pkgs.upstart;
userExists = u:
(u == "") || any (uu: uu.name == u) (attrValues config.users.extraUsers);
groupExists = g:
(g == "") || any (gg: gg.name == g) (attrValues config.users.extraGroups);
# From a job description, generate an Upstart job file.
makeJob = job:
let
hasMain = job.script != "" || job.exec != "";
env = config.system.upstartEnvironment // job.environment;
jobText =
let log = "/var/log/upstart/${job.name}"; in
''
# Upstart job `${job.name}'. This is a generated file. Do not edit.
${optionalString (job.description != "") ''
description "${job.description}"
''}
${if isList job.startOn then
"start on ${concatStringsSep " or " job.startOn}"
else if job.startOn != "" then
"start on ${job.startOn}"
else ""
}
${optionalString (job.stopOn != "") "stop on ${job.stopOn}"}
env PATH=${job.path}
${concatMapStrings (n: "env ${n}=\"${getAttr n env}\"\n") (attrNames env)}
${optionalString (job.console != "") "console ${job.console}"}
pre-start script
${optionalString (job.console == "") ''
exec >> ${log} 2>&1
''}
ln -sfn "$(readlink -f "/etc/init/${job.name}.conf")" /var/run/upstart-jobs/${job.name}
${optionalString (job.preStart != "") ''
source ${jobHelpers}
${job.preStart}
''}
end script
${if job.script != "" && job.exec != "" then
abort "Job ${job.name} has both a `script' and `exec' attribute."
else if job.script != "" then
''
script
${optionalString (job.console == "") ''
exec >> ${log} 2>&1
''}
source ${jobHelpers}
${job.script}
end script
''
else if job.exec != "" && job.console == "" then
''
script
exec >> ${log} 2>&1
exec ${job.exec}
end script
''
else if job.exec != "" then
''
exec ${job.exec}
''
else ""
}
${optionalString (job.postStart != "") ''
post-start script
${optionalString (job.console == "") ''
exec >> ${log} 2>&1
''}
source ${jobHelpers}
${job.postStart}
end script
''}
${optionalString job.task "task"}
${optionalString (!job.task && job.respawn) "respawn"}
${ # preStop is run only if there is exec or script.
# (upstart 0.6.5, job.c:562)
optionalString (job.preStop != "") (assert hasMain; ''
pre-stop script
${optionalString (job.console == "") ''
exec >> ${log} 2>&1
''}
source ${jobHelpers}
${job.preStop}
end script
'')}
${optionalString (job.postStop != "") ''
post-stop script
${optionalString (job.console == "") ''
exec >> ${log} 2>&1
''}
source ${jobHelpers}
${job.postStop}
end script
''}
${if job.daemonType == "fork" then "expect fork" else
if job.daemonType == "daemon" then "expect daemon" else
if job.daemonType == "stop" then "expect stop" else
if job.daemonType == "none" then "" else
throw "invalid daemon type `${job.daemonType}'"}
${optionalString (job.setuid != "") ''
setuid ${job.setuid}
''}
${optionalString (job.setgid != "") ''
setuid ${job.setgid}
''}
${job.extraConfig}
'';
in
pkgs.runCommand ("upstart-" + job.name + ".conf")
{ inherit (job) buildHook; inherit jobText; preferLocalBuild = true; }
''
eval "$buildHook"
echo "$jobText" > $out
'';
# Shell functions for use in Upstart jobs.
jobHelpers = pkgs.writeText "job-helpers.sh"
''
# Ensure that an Upstart service is running.
ensure() {
local job="$1"
local status="$(status "$job")"
# If it's already running, we're happy.
[[ "$status" =~ start/running ]] && return 0
# If its current goal is to stop, start it.
[[ "$status" =~ stop/ ]] && { status="$(start "$job")" || true; }
# The "start" command is synchronous *if* the job is
# not already starting. So if somebody else started
# the job in parallel, the "start" above may return
# while the job is still starting. So wait until it
# is up or has failed.
while true; do
[[ "$status" =~ stop/ ]] && { echo "job $job failed to start"; return 1; }
[[ "$status" =~ start/running ]] && return 0
echo "waiting for job $job to start..."
sleep 1
status="$(status "$job")"
done
}
# Check whether the current job has been stopped. Used in
# post-start jobs to determine if they should continue.
stop_check() {
local status="$(status)"
if [[ "$status" =~ stop/ ]]; then
echo "job asked to stop!"
return 1
fi
if [[ "$status" =~ respawn/ ]]; then
echo "job respawning unexpectedly!"
stop
return 1
fi
return 0
}
'';
jobOptions = {
name = mkOption {
# !!! The type should ensure that this could be a filename.
type = types.string;
example = "sshd";
description = ''
Name of the Upstart job.
'';
};
buildHook = mkOption {
type = types.string;
default = "true";
description = ''
Command run while building the Upstart job. Can be used
to perform simple regression tests (e.g., the Apache
Upstart job uses it to check the syntax of the generated
httpd.conf.
'';
};
description = mkOption {
type = types.string;
default = "";
description = ''
A short description of this job.
'';
};
startOn = mkOption {
# !!! Re-enable this once we're on Upstart >= 0.6.
#type = types.string;
default = "";
description = ''
The Upstart event that triggers this job to be started.
If empty, the job will not start automatically.
'';
};
stopOn = mkOption {
type = types.string;
default = "starting shutdown";
description = ''
The Upstart event that triggers this job to be stopped.
'';
};
preStart = mkOption {
type = types.string;
default = "";
description = ''
Shell commands executed before the job is started
(i.e. before the job's main process is started).
'';
};
postStart = mkOption {
type = types.string;
default = "";
description = ''
Shell commands executed after the job is started (i.e. after
the job's main process is started), but before the job is
considered “running”.
'';
};
preStop = mkOption {
type = types.string;
default = "";
description = ''
Shell commands executed before the job is stopped
(i.e. before Upstart kills the job's main process). This can
be used to cleanly shut down a daemon.
'';
};
postStop = mkOption {
type = types.string;
default = "";
description = ''
Shell commands executed after the job has stopped
(i.e. after the job's main process has terminated).
'';
};
exec = mkOption {
type = types.string;
default = "";
description = ''
Command to start the job's main process. If empty, the
job has no main process, but can still have pre/post-start
and pre/post-stop scripts, and is considered “running”
until it is stopped.
'';
};
script = mkOption {
type = types.string;
default = "";
description = ''
Shell commands executed as the job's main process. Can be
specified instead of the exec attribute.
'';
};
respawn = mkOption {
type = types.bool;
default = true;
description = ''
Whether to restart the job automatically if its process
ends unexpectedly.
'';
};
restartIfChanged = mkOption {
type = types.bool;
default = true;
description = ''
Whether the job should be restarted if it has changed after a
NixOS configuration switch.
'';
};
task = mkOption {
type = types.bool;
default = false;
description = ''
Whether this job is a task rather than a service. Tasks
are executed only once, while services are restarted when
they exit.
'';
};
environment = mkOption {
type = types.attrs;
default = {};
example = { PATH = "/foo/bar/bin"; LANG = "nl_NL.UTF-8"; };
description = ''
Environment variables passed to the job's processes.
'';
};
daemonType = mkOption {
type = types.string;
default = "none";
description = ''
Determines how Upstart detects when a daemon should be
considered “running”. The value none means
that the daemon is considered ready immediately. The value
fork means that the daemon will fork once.
The value daemon means that the daemon will
fork twice. The value stop means that the
daemon will raise the SIGSTOP signal to indicate readiness.
'';
};
setuid = mkOption {
type = types.string;
check = userExists;
default = "";
description = ''
Run the daemon as a different user.
'';
};
setgid = mkOption {
type = types.string;
check = groupExists;
default = "";
description = ''
Run the daemon as a different group.
'';
};
extraConfig = mkOption {
type = types.string;
default = "";
example = "limit nofile 4096 4096";
description = ''
Additional Upstart stanzas not otherwise supported.
'';
};
path = mkOption {
default = [ ];
apply = ps: "${makeSearchPath "bin" ps}:${makeSearchPath "sbin" ps}";
description = ''
Packages added to the job's PATH environment variable.
Both the bin and sbin
subdirectories of each package are added.
'';
};
console = mkOption {
default = "";
example = "console";
description = ''
If set to output, job output is written to
the console. If it's owner, additionally
the job becomes owner of the console. It it's empty (the
default), output is written to
/var/log/upstart/jobname
'';
};
};
upstartJob = {name, config, ...}: {
options = {
jobDrv = mkOption {
default = makeJob config;
type = types.uniq types.package;
description = ''
Derivation that builds the Upstart job file. The default
value is generated from other options.
'';
};
};
config = {
# The default name is the name extracted from the attribute path.
name = mkDefaultValue name;
# Default path for Upstart jobs. Should be quite minimal.
path =
[ pkgs.coreutils
pkgs.findutils
pkgs.gnugrep
pkgs.gnused
upstart
];
};
};
in
{
###### interface
options = {
jobs = mkOption {
default = {};
description = ''
This option defines the system jobs started and managed by the
Upstart daemon.
'';
type = types.loaOf types.optionSet;
options = [ jobOptions upstartJob ];
};
tests.upstartJobs = mkOption {
internal = true;
default = {};
description = ''
Make it easier to build individual Upstart jobs. (e.g.,
nix-build /etc/nixos/nixos -A
tests.upstartJobs.xserver).
'';
};
system.upstartEnvironment = mkOption {
type = types.attrs;
default = {};
example = { TZ = "CET"; };
description = ''
Environment variables passed to all Upstart jobs.
'';
};
};
###### implementation
config = {
system.build.upstart = upstart;
/*
environment.etc =
flip map (attrValues config.jobs) (job:
{ source = job.jobDrv;
target = "init/${job.name}.conf";
} );
# Upstart can listen on the system bus, allowing normal users to
# do status queries.
services.dbus.packages = [ upstart ];
system.activationScripts.chownJobLogs = stringAfter ["var"]
(concatMapStrings (job: ''
touch /var/log/upstart/${job.name}
${optionalString (job.setuid != "") "chown ${job.setuid} /var/log/upstart/${job.name}"}
${optionalString (job.setgid != "") "chown :${job.setgid} /var/log/upstart/${job.name}"}
'') (attrValues config.jobs));
*/
};
}