Wie man ein Python-Skript wie einen Dienst oder Daemon in Linux laufen lässt

Sie haben hier zwei Möglichkeiten.

1. Machen Sie einen richtigen Cronjob das ruft Ihr Skript auf. Cron ist ein gebräuchlicher Name für einen GNU/Linux-Daemon, der regelmäßig Skripte nach einem von Ihnen festgelegten Zeitplan startet. Sie fügen Ihr Skript in eine Crontab ein oder platzieren einen symbolischen Link darauf in einem speziellen Verzeichnis, und der Daemon übernimmt die Aufgabe, es im Hintergrund zu starten. Sie können mehr bei Wikipedia lesen. Es gibt eine Vielzahl unterschiedlicher Cron-Daemons, aber Ihr GNU/Linux-System sollte sie bereits installiert haben.

2. Verwenden Sie eine Art Python-Ansatz (z. B. eine Bibliothek), damit Ihr Skript sich selbst daemonisieren kann. Ja, es wird eine einfache Ereignisschleife benötigt (wobei Ihre Ereignisse zeitgesteuert ausgelöst werden, möglicherweise bereitgestellt durch die Schlaffunktion).

Ich würde Ihnen nicht empfehlen, 2. zu wählen, da Sie tatsächlich die Cron-Funktionalität wiederholen würden. Das Paradigma des Linux-Systems besteht darin, mehrere einfache Tools interagieren zu lassen und Ihre Probleme zu lösen. Wenn es keine weiteren Gründe gibt, warum Sie einen Daemon erstellen sollten (zusätzlich zum regelmäßigen Auslösen), wählen Sie den anderen Ansatz.

Wenn Sie daemonize mit einer Schleife verwenden und ein Absturz auftritt, wird danach niemand die E-Mail überprüfen (wie von Ivan Nevostruev in Kommentaren zu dieser Antwort hervorgehoben). Wenn das Skript hingegen als Cron-Job hinzugefügt wird, wird es einfach erneut ausgelöst.

Hier ist eine schöne Klasse, die von hier stammt:

#!/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)
                http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
                """
                try:
                        pid = os.fork()
                        if pid > 0:
                                # exit first parent
                                sys.exit(0)
                except OSError, e:
                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
                        sys.exit(1)

                # decouple from parent environment
                os.chdir("/")
                os.setsid()
                os.umask(0)

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

                # redirect standard file descriptors
                sys.stdout.flush()
                sys.stderr.flush()
                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
                atexit.register(self.delpid)
                pid = str(os.getpid())
                file(self.pidfile,'w+').write("%s\n" % pid)

        def delpid(self):
                os.remove(self.pidfile)

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

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

                # Start the daemon
                self.daemonize()
                self.run()

        def stop(self):
                """
                Stop the daemon
                """
                # Get the pid from the pidfile
                try:
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                        pf.close()
                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       
                try:
                        while 1:
                                os.kill(pid, SIGTERM)
                                time.sleep(0.1)
                except OSError, err:
                        err = str(err)
                        if err.find("No such process") > 0:
                                if os.path.exists(self.pidfile):
                                        os.remove(self.pidfile)
                        else:
                                print str(err)
                                sys.exit(1)

        def restart(self):
                """
                Restart the daemon
                """
                self.stop()
                self.start()

        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().
                """