Post History

I did not find a way to get Rocket and Daemonize to work together without problems. However, I was able to get a more recent version of `start-stop-daemon` installed in the system (v1.20.11), and was able to get an `init` script working. (The old version did not recognize some options such as PID file, I/O redirection, etc.) With this in place, I've completely removed the dependency on the `daemonize` crate and I'm now using Rocket by itself.

Here's the working `init` script I'm using, but as a template with placeholders for you to adapt it to your own needs:

```bash
#!/bin/bash
### BEGIN INIT INFO
# Provides:          <daemon>
# Required-Start:    $syslog $time $remote_fs
# Required-Stop:     $syslog $time $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Full Daemon Name
# Description:       Full description
### END INIT INFO
#
# Author:            ghost-in-the-zsh <ghost-in-the-zsh@example.com>
#
# Copy this script to `/etc/init.d/<daemon>` and run:
#   $ update-rc.d <daemon> defaults
#   $ /etc/init.d/<daemon> {start|stop|restart|status}
#
# Reference man pages:
#
#   1. init-d-script
#   2. update-rc.d
#   3. start-stop-daemon
#
set -e

# `init` consts; these names are meaningful to `init`
# see `man init-d-script`
NAME=<daemon>
DESC="Daemon Description Here"
DAEMON=/path/to-daemon/${NAME}
DAEMON_ARGS="--options for-your-daemon"
PIDFILE=/run/${NAME}.pid

# custom consts; these can be whatever we want
LOGFILE=/var/log/${NAME}.log
ACCOUNT=${NAME}
TIMEOUT=5

## service management functions
start() {
    echo "Starting ${NAME} ..."
    start-stop-daemon --start \
        --background \
        --startas ${DAEMON} \
        --name ${NAME} \
        --user ${ACCOUNT} \
        --chuid ${ACCOUNT} \
        --pidfile ${PIDFILE} \
        --output ${LOGFILE} \
        --make-pidfile \
        --oknodo \
        --quiet \
        -- ${DAEMON_ARGS}
    return ${?}
}

stop() {
    echo "Stopping ${NAME} ..."
    start-stop-daemon --stop \
        --user ${ACCOUNT} \
        --name ${NAME} \
        --oknodo \
        --pidfile ${PIDFILE} \
        --remove-pidfile \
        --retry ${TIMEOUT}
    return ${?}
}

status() {
    echo -n "${NAME} status: "
    start-stop-daemon --status \
        --name ${NAME} \
        --pidfile ${PIDFILE}

    local rc=${?}
    case ${rc} in
        0)
            echo "running"
            ;;
        1)
            echo "stopped"
            ;;
        *)
            echo "unknown"
            ;;
    esac
    return ${rc}
}

## case block to call management functions
case "${1}" in
    start)
        start
        retcode=${?}
        ;;
    stop)
        stop
        retcode=${?}
        ;;
    status)
        status
        retcode=${?}
        ;;
    restart)
        stop && start
        retcode=${?}
        ;;
    *)
        echo "Usage: ${0} {start|stop|restart|status}"
        retcode=1
esac

exit ${retcode}
```

Note that if you have the `service` utility installed, then you should be able to run `service <daemon> {start|stop|restart|status}` instead of using the full `/etc/init.d/<daemon>` path.

Also, as a bonus, here's the Systemd service unit I played around with in my local system, as an alternative for a possible future. It's also given as a template with placeholders:

```
# Enable : systemctl enable <daemon>.service
# Control: systemctl {start|stop|...} <daemon>.service
[Unit]
Description=Daemon Description Here
Documentation=https://<somewhere>.<something>/<project>
Before=<before>.service
After=<after-1>.target
After=<after-2>.target

[Service]
Type=simple
ExecStart=/path/to/<daemon>
Restart=always
User=<daemon>
Group=<daemon>
WorkingDirectory=/path/to/daemon/workdir
# systemd v240 and newer; otherwise must rely on `journalctl -eu <daemon>.service`
StandardOutput=append:/var/log/<daemon>.log
StandardError=append:/var/log/<daemon>.log

[Install]
WantedBy=multi-user.target
```

This last one is controlled via `systemctl`.