How to make a Python script run like a service or daemon in Linux

Python Programming

Question or problem about Python programming:

I have written a Python script that checks a certain e-mail address and passes new e-mails to an external program. How can I get this script to execute 24/7, such as turning it into daemon or service in Linux. Would I also need a loop that never ends in the program, or can it be done by just having the code re executed multiple times?

How to solve the problem:

Solution 1:

You have two options here.

  1. Make a proper cron job that calls your script. Cron is a common name for a GNU/Linux daemon that periodically launches scripts according to a schedule you set. You add your script into a crontab or place a symlink to it into a special directory and the daemon handles the job of launching it in the background. You can read more at Wikipedia. There is a variety of different cron daemons, but your GNU/Linux system should have it already installed.

  2. Use some kind of python approach (a library, for example) for your script to be able to daemonize itself. Yes, it will require a simple event loop (where your events are timer triggering, possibly, provided by sleep function).

I wouldn’t recommend you to choose 2., because you would be, in fact, repeating cron functionality. The Linux system paradigm is to let multiple simple tools interact and solve your problems. Unless there are additional reasons why you should make a daemon (in addition to trigger periodically), choose the other approach.

Also, if you use daemonize with a loop and a crash happens, no one will check the mail after that (as pointed out by Ivan Nevostruev in comments to this answer). While if the script is added as a cron job, it will just trigger again.

Solution 2:

Here’s a nice class that is taken from here:

#!/usr/bin/env python

import sys, os, time, atexit
from signal import SIGTERM

class Daemon:
        A generic daemon class.

        Usage: subclass the Daemon class and override the run() method
        def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
                self.stdin = stdin
                self.stdout = stdout
                self.stderr = stderr
                self.pidfile = pidfile

        def daemonize(self):
                do the UNIX double-fork magic, see Stevens' "Advanced
                Programming in the UNIX Environment" for details (ISBN 0201563177)
                        pid = os.fork()
                        if pid > 0:
                                # exit first parent
                except OSError, e:
                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))

                # decouple from parent environment

                # do second fork
                        pid = os.fork()
                        if pid > 0:
                                # exit from second parent
                except OSError, e:
                        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))

                # redirect standard file descriptors
                si = file(self.stdin, 'r')
                so = file(self.stdout, 'a+')
                se = file(self.stderr, 'a+', 0)
                os.dup2(si.fileno(), sys.stdin.fileno())
                os.dup2(so.fileno(), sys.stdout.fileno())
                os.dup2(se.fileno(), sys.stderr.fileno())

                # write pidfile
                pid = str(os.getpid())
                file(self.pidfile,'w+').write("%s\n" % pid)

        def delpid(self):

        def start(self):
                Start the daemon
                # Check for a pidfile to see if the daemon already runs
                        pf = file(self.pidfile,'r')
                        pid = int(
                except IOError:
                        pid = None

                if pid:
                        message = "pidfile %s already exist. Daemon already running?\n"
                        sys.stderr.write(message % self.pidfile)

                # Start the daemon

        def stop(self):
                Stop the daemon
                # Get the pid from the pidfile
                        pf = file(self.pidfile,'r')
                        pid = int(
                except IOError:
                        pid = None

                if not pid:
                        message = "pidfile %s does not exist. Daemon not running?\n"
                        sys.stderr.write(message % self.pidfile)
                        return # not an error in a restart

                # Try killing the daemon process       
                        while 1:
                                os.kill(pid, SIGTERM)
                except OSError, err:
                        err = str(err)
                        if err.find("No such process") > 0:
                                if os.path.exists(self.pidfile):
                                print str(err)

        def restart(self):
                Restart the daemon

        def run(self):
                You should override this method when you subclass Daemon. It will be called after the process has been
                daemonized by start() or restart().

Solution 3:

You should use the python-daemon library, it takes care of everything.

From PyPI: Library to implement a well-behaved Unix daemon process.

Solution 4:

You can use fork() to detach your script from the tty and have it continue to run, like so:

import os, sys
fpid = os.fork()
if fpid!=0:
  # Running as daemon now. PID is fpid

Of course you also need to implement an endless loop, like

while 1:

Hope this get’s you started.

Solution 5:

You can also make the python script run as a service using a shell script. First create a shell script to run the python script like this (scriptname arbitary name)

script='/home/.. full path to script'
/usr/bin/python $script &

now make a file in /etc/init.d/scriptname

#! /bin/sh

DAEMON=/home/.. path to shell script scriptname created to run python script

test -x $DAEMON || exit 0

. /lib/lsb/init-functions

case "$1" in
     log_daemon_msg "Starting feedparser"
     start_daemon -p $PIDFILE $DAEMON
     log_end_msg $?
     log_daemon_msg "Stopping feedparser"
     killproc -p $PIDFILE $DAEMON
     PID=`ps x |grep feed | head -1 | awk '{print $1}'`
     kill -9 $PID       
     log_end_msg $?
     $0 stop
     $0 start
     status_of_proc -p $PIDFILE $DAEMON atd && exit 0 || exit $?
   echo "Usage: /etc/init.d/atd {start|stop|restart|force-reload|status}"
   exit 1

exit 0

Now you can start and stop your python script using the command /etc/init.d/scriptname start or stop.

Hope this helps!