examples/var_service/README_distro_proposal.txt

	A distro which already uses runit

I installed Void Linux, in order to see what do they have.
Xfce desktop looks fairly okay, network is up.
ps tells me they did put X, dbus, NM and udev into runsvdir-supervised tree:

    1 ?        00:00:01 runit
  623 ?        00:00:00   runsvdir
  629 ?        00:00:00     runsv
  650 tty1     00:00:00       agetty
  630 ?        00:00:00     runsv
  644 ?        00:00:09       NetworkManager
 1737 ?        00:00:00         dhclient
  631 ?        00:00:00     runsv
  639 tty4     00:00:00       agetty
  632 ?        00:00:00     runsv
  640 ?        00:00:00       sshd
 1804 ?        00:00:00         sshd
 1809 pts/3    00:00:00           sh
 1818 pts/3    00:00:00             ps
  633 ?        00:00:00     runsv
  637 tty5     00:00:00       agetty
  634 ?        00:00:00     runsv
  796 ?        00:00:00       dhclient
  635 ?        00:00:00     runsv
  649 ?        00:00:00       uuidd
  636 ?        00:00:00     runsv
  647 ?        00:00:00       acpid
  638 ?        00:00:00     runsv
  652 ?        00:00:00       console-kit-dae
  641 ?        00:00:00     runsv
  651 tty6     00:00:00       agetty
  642 ?        00:00:00     runsv
  660 tty2     00:00:00       agetty
  643 ?        00:00:00     runsv
  657 ?        00:00:02       dbus-daemon
  645 ?        00:00:00     runsv
  658 ?        00:00:00       cgmanager
  648 ?        00:00:00     runsv
  656 tty3     00:00:00       agetty
  653 ?        00:00:00     runsv
  655 ?        00:00:00       lxdm-binary
  698 tty7     00:00:14         Xorg
  729 ?        00:00:00         lxdm-session
  956 ?        00:00:00           sh
  982 ?        00:00:00             xfce4-session
 1006 ?        00:00:04               nm-applet
  654 ?        00:00:00     runsv
  659 ?        00:00:00       udevd

Here is a link to Void Linux's wiki:

    https://wiki.voidlinux.eu/Runit

Void Linux packages install their services as subdirectories of /etc/rc,
such as /etc/sv/sshd, with a script file, "run", and a link
"supervise" -> /run/runit/supervise.sshd

For sshd, "run" contains:

    #!/bin/sh
    ssh-keygen -A >/dev/null 2>&1 # generate host keys if they don't exist
    [ -r conf ] && . ./conf
    exec /usr/bin/sshd -D $OPTS

That's it from the POV of the packager.

This is pretty minimalistic, and yet, it is already distro-specific:
the link to /run/runit/* is conceptually wrong, it requires packagers
to know that /etc/rc should not be mutable and thus they need to use
a different location in filesystem for supervise/ directory.

I think a good thing would be to require just one file: the "run" script.
The rest should be handled by distro tooling, not by packager.

A similar issue is arising with logging. It would be ideal if packagers
would not need to know how a particular distro manages logs.
Whatever their daemons print to stdout/stderr, should be automagically logged
in a way distro prefers.

* * * * * * * *

	Proposed "standard" on how distros should use runit

The original idea of services-as-directories belongs to D.J.Bernstein (djb),
and his project to implement it is daemontools: https://cr.yp.to/daemontools.html

There are several reimplementations of daemontools:
- runit: by Gerrit Pape, http://smarden.org/runit/
  (busybox has it included)
- s6: by Laurent Bercot, http://skarnet.org/software/s6/

It is not required that a specific clone should be used. Let evolution work.


	Terminology

daemon: any long running background program. Common examples are sshd, getty,
ntpd, dhcp client...

service: daemon controlled by a service monitor.

service directory: a directory with an executable file (script) named "run"
which (usually) execs some daemon, possibly after some preparatory steps.
It should start it not as a child or daemonized process, but by exec'ing it
(inheriting the same PID and the place in the process tree).

service monitor: a tool which watches a set of service directories.
In daemontools package, it is called "svscan". In runit, it is called
"runsvdir". In s6, it is called "s6-svscan".
Service monitor starts a supervisor for each service directory.
If it dies, it restarts it. If service directory disappears,
service monitor will not be restarted if it dies.
runit's service monitor (runsvdir) sends SIGTERM to supervisors
whose directories disappeared.

supervisor: a tool which monitors one service directory.
It runs "run" script as its child. It restarts it if it dies.
It can be instructed to start/stop/signal its child.
In daemontools package, it is called "supervise". In runit, it is called
"runsv". In s6, it is called "s6-supervise".

Conceptually, a daemontools clone can be designed such that it does not *have*
the supervisor component: service monitor can directly monitor all its daemons
(for example, this may be a good idea for memory-constrained systems).
However all three existing projects (daemontools/runit/s6) do have a per-service
supervisor process.

log service: a service which is exclusively tasked with logging
the output of another service. It is implemented as log/ subdirectory
in a service directory. It has the same structure as "normal"
service dirs: it has a "run" script which starts a logging tool.

If log service exists, stdout of its "main" service is piped
to log service. Stops/restarts of either of them do not sever the pipe
between them.

If log service exists, daemontools and s6 run a pair of supervisors
(one for the daemon, one for the logger); runit runs only one supervisor
per service, which is handling both of them (presumably this is done
to use fewer processes and thus, fewer resources).


	User API

"Users" of service monitoring are authors of software which has daemons.
They need to package their daemons to be installed as services at package
install time. And they need to do this for many distros.
The less distros diverge, the easier users' lives are.

System-wide service dirs reside in a distro-specific location.
The recommended location is /var/service. (However, since it is not
a mandatory location, avoid depending on it in your run scripts.
Void Linux wanted to have it somewhere in /run/*, and they solved this
by making /var/service a symlink).

The install location for service dirs is /etc/rc:
when e.g. ntpd daemon is installed, it creates the /etc/rc/ntpd
directory with (minimally) one executable file (script) named "run"
which starts ntpd daemon. It can have other files there.

At boot, distro should copy /etc/rc/* to a suitable writable
directory (common choice are /var/service, /run/service etc).
It should create log/ directories in each subdirectory
and create "run" files in them with suitable (for this particular distro)
logging tool invocation, unless this directory chose to channel
all logging from all daemons through service monitor process
and log all of them into one file/database/whatever,
in which case log/ directories should not be created.

It is allowable for a distro to directly use /etc/rc/ as the only
location of its service directories. (For example,
/var/service may be a symlink to /etc/rc).
However, it poses some problems:

(1) Supervision tools will need to write to subdirectories:
the control of running daemons is implemented via some files and fifos
in automatically created supervise/ subdirectory in each /etc/rc/DIR.

(2) Creation of a new service can race with the rescanning of /etc/rc/
by service monitor: service monitor may see a directory with only some files
present. If it attempts to start the service in this state, all sorts
of bad things may happen. This may be worked around by various
heuristics in service monitor which give new service a few seconds
of "grace time" to be fully populated; but this is not yet
implemented in any of three packages.
This also may be worked around by creating a .dotdir (a directory
whose name starts with a dot), populating it, and then renaming;
but packaging tools usually do not have an option to do this
automatically - additional install scripting in packages will be needed.

Daemons' output file descriptors are handled somewhat awkwardly
by various daemontools implementations. For example, for runit tools,
daemons' stdout goes to wherever runsvdir's stdout was directed;
stderr goes to runsvdir, which in turn "rotates" it on its command line
(which is visible in ps output).

Hopefully this get changed/standardized; while it is not, the "run" file
should start with a

    exec 2>&1

command, making stderr equivalent to stdout.
An especially primitive service which does not want its output to be logged
with standard tools can do

    exec >LOGFILE 2>&1

or even

    exec >/dev/null 2>&1

To prevent creation of distro-specific log/ directory, a service directory
in /etc/rc can contain an empty "log" file.


	Controlling daemons

The "svc" tool is available for admins and scripts to control services.
In particular, often one service needs to control another:
e.g. ifplugd can detect that the network cable was just plugged in,
and it needs to (re)start DHCP service for this network device.

The name of this tool is not standard either, which is an obvious problem.
I propose to fix this by implementing a tool with fixed name and API by all
daemontools clones. Lets use original daemontools name and API. Thus:

The following form must work:

	svc -udopchaitkx DIR

Options map to up/down/once/STOP/CONT/HUP/ALRM/INT/TERM/KILL/exit
commands to the daemon being controlled.

The form with one option letter must work. If multiple-option form
is supported, there is no guarantee in which order they take effect:
svc -it DIR can deliver TERM and INT in any order.

If more than one DIR can be specified (which is not a requirement),
there is no guarantee in which order commands are sent to them.

If DIR has no slash and is not "." or "..", it is assumed to be
relative to the system-wide service directory.

[Currently, "svc" exists only in daemontools and in busybox.
This proposal asks developers of other daemontools implementations
to add "svc" command to their projects]

The "svok DIR" tool exits 0 if service supervisor is running
(with service itself either running or stopped), and nonzero if not.

Other tools with different names and APIs may exist; however
for portability scripts should use the above tools.

Creation of a new service on a running system should be done atomically.
To this end, first create and populate a new /etc/rc/DIR.

Then "activate" it by running ??????? - this copies (or symlinks,
depending on the distro) its files to the "live" service directory,
wherever it is located on this distro.

Removal of the service should be done as follows:
svc -d DIR [DIR/log], then remove the service directory:
this makes service monitor SIGTERM per-directory supervisors
(if they exist in the implementation).


	Implementation details

Top-level service monitor program name is not standardized
[svscan, runsvdir, s6-svscan ...] - it does not need to be,
as far as daemon packagers are concerned.

It may run one per-directory supervisor, or two supervisors
(one for DIR/ and one for DIR/log/); for memory-constrained systems
an implementation is possible which itself controls all services, without
intermediate supervisors.
[runsvdir runs one "runsv DIR" per DIR, runsv handles DIR/log/ if that exists]
[svscan runs a pair of "supervise DIR" and "supervise DIR/log"]

Directories are remembered by device+inode numbers, not names. Renaming a directory
does not affect the running service (unless it is renamed to a .dotdir).

Removal (or .dotdiring) of a directory sends SIGTERM to any running services.

Standard output of non-logged services goes to standard output of service monitor.
Standard output of logger services goes to standard output of service monitor.
Standard error of them always goes to standard error of service monitor.

If you want to log standard error of your logged service along with its stdout, use
"exec 2>&1" in the beginning of your "run" script.

Whether stdout/stderr of service monitor is discarded (>/dev/null)
or logged in some way is system-dependent.


	Containers

[What do containers need?]