Windows CE to Raspbian - Pt. 3: Daemon Scripts for Mono Services

The purpose of this particular post is to explain how to script your mono-service2 as a daemon and register that daemon to run at start-up and be killed at shutdown. It’s important to note this post explains how to script daemons for Raspbian on Wheezy using init.d not system.d. At the time of writing this post the latest version of Raspbian used Wheezy.

This is part three of a series of posts: click here for the previous post.

Scripting Daemons

Overview

As mentioned in the first post, migrating services from Windows to Linux is not straight forward as the concept of a service is very different in Linux. To begin with we need to script the daemon, this is how we can refer to the service later on and define some behaviours for it, e.g. stop, start reload, as well as some meta data. Daemons are scripted in bash which is fairly easy to get into and is highly recommended for any prolonged work in Linux: eventually you just start writing bash scripts to do your job for you.

Daemon Script

Below is an example of the script used to daemonise our service. This is based on the skeleton script found in /etc/init.d/skeleton.

#!/bin/sh
### BEGIN INIT INFO
# Provides:          my-service
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Short description.
# Description:       Longer description.
### END INIT INFO

# Author: Sam Albon 

# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="Description Goes Here!"
NAME=MyService
DAEMON=/usr/bin/mono-service2
DAEMON_ARGS=/usr/bin/2PGames/myservice.exe
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
#[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
#. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
	# Return
	#   0 if daemon has been started
	#   1 if daemon was already running
	#   2 if daemon could not be started
	start-stop-daemon --start --quiet --make-pidfile --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
		|| return 1
	start-stop-daemon --start --quiet --make-pidfile --pidfile $PIDFILE --exec $DAEMON -- \
		$DAEMON_ARGS \
		|| return 2
	# Add code here, if necessary, that waits for the process to be ready
	# to handle requests from services started subsequently which depend
	# on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
	# Return
	#   0 if daemon has been stopped
	#   1 if daemon was already stopped
	#   2 if daemon could not be stopped
	#   other if a failure occurred
	start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE
	RETVAL="$?"
	[ "$RETVAL" = 2 ] && return 2
	# Wait for children to finish too if this is a daemon that forks
	# and if the daemon is only ever run from this initscript.
	# If the above conditions are not satisfied then add some other code
	# that waits for the process to drop all resources that could be
	# needed by services started subsequently.  A last resort is to
	# sleep for some time.
	start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
	[ "$?" = 2 ] && return 2
	# Many daemons don't delete their pidfiles when they exit.
	rm -f $PIDFILE
	return "$RETVAL"
}

#
# Function that sends a SIGHUP to the daemon/service
#
do_reload() {
	#
	# If the daemon can reload its configuration without
	# restarting (for example, when it is sent a SIGHUP),
	# then implement that here.
	#
	start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE
	return 0
}

case "$1" in
  start)
	[ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
	do_start
	case "$?" in
		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
	esac
	;;
  stop)
	[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
	do_stop
	case "$?" in
		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
	esac
	;;
  status)
	status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
	;;
  #reload|force-reload)
	#
	# If do_reload() is not implemented then leave this commented out
	# and leave 'force-reload' as an alias for 'restart'.
	#
	#log_daemon_msg "Reloading $DESC" "$NAME"
	#do_reload
	#log_end_msg $?
	#;;
  restart|force-reload)
	#
	# If the "reload" option is implemented then remove the
	# 'force-reload' alias
	#
	log_daemon_msg "Restarting $DESC" "$NAME"
	do_stop
	case "$?" in
	  0|1)
		do_start
		case "$?" in
			0) log_end_msg 0 ;;
			1) log_end_msg 1 ;; # Old process is still running
			*) log_end_msg 1 ;; # Failed to start
		esac
		;;
	  *)
		# Failed to stop
		log_end_msg 1
		;;
	esac
	;;
  *)
	#echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
	echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
	exit 3
	;;
esac

:

Script Location

Once you’ve created your script it needs to be moved into /etc/init.d and made executable. You can make your script executable by running the following command as super user:

1	chmod +x MyService

Running the Service

This will allow you to begin to refer to the daemon. You should now be able to manually start, stop and reload the service by using the name.

1	service MyService start\|stop\|reload

Running Service on Startup

Overview

Now the daemon has been scripted it can be referenced during startup and shutdown. This can be done by linking the script from init.d into the appropriate run levels.

Startup

There are seven run levels in Debian, however the run levels we want for startup are 2 - 5 (full multi-user mode).

To link these to the run levels use the command ln -nsf with the script name and destination location for the run condition, which is /etc/rc.d/ with the script name prefixed with S99. This tells Linux to start the service (_S_) and in the oder of _99_, as each service is started in a specific order due to dependencies. Linux will later rearrange the order as it sees fit, so the number is largely irrelevant.

ln -nsf /etc/init.d/MyService /etc/rc2.d/S99MyService
ln -nsf /etc/init.d/MyService /etc/rc3.d/S99MyService
ln -nsf /etc/init.d/MyService /etc/rc4.d/S99MyService
ln -nsf /etc/init.d/MyService /etc/rc5.d/S99MyService

Shutdown

The runlevels desired for shutdown are 0 (system halt), 1 (single user) and 6 (system reboot). This is done similar to the startup links but using the prefix K01, again Linux will rearrange the shutdown order as it sees fit.

1
2
3

ln -nsf /etc/init.d/MyService /etc/rc0.d/K01MyService
ln -nsf /etc/init.d/MyService /etc/rc1.d/K01MyService
ln -nsf /etc/init.d/MyService /etc/rc6.d/K01MyService

Finally

In order to finalise the scripts being registered run update-rc.d with the daemon name and which run levels to enable. This is should also rearrange the start and kill orders for the new script links.

1	update-rc.d MyService enable 2 3 4 5

If you reboot the device you should now see it appear during boot in the order it’s decided for you, looking something like this:

1	[ ok ] Starting Description Goes Here! : MyService