Python-Daemon wird unter Ubuntu nicht im Hintergrund ausgeführt

Question

Mein Python-Daemon läuft problemlos im Vordergrund meines Ubuntu-Systems mit diesem Befehl im Terminal:

python /opt/my-daemon.py foreground

Wenn ich jedoch versuche, den Daemon mit der Option "Start" Befehl scheitert es, warum?

python /opt/my-daemon.py start

So rufe ich den Befehl in der Datei /etc/rc.local Datei:

python /opt/my-daemon.py start &

Hier ist der Code:

1.daemon.py

#!/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 Richard 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().
    """

2.mein-daemon.py

import sys, time
from daemon import Daemon
import MySQLdb #MySQL libraries
#Database parameters
config = {"host":"localhost",...}
try:
    conn = MySQLdb.connect(config['host'],...
class MyDaemon(Daemon):
def run(self):
    while True:
        time.sleep(2)
                    #{Do processes, connect to the database, etc....}
                    ...
if __name__ == "__main__":
daemon = MyDaemon('/tmp/daemon-example.pid')
if len(sys.argv) == 2:
    if 'start' == sys.argv[1]:
        daemon.start()
    elif 'stop' == sys.argv[1]:
        daemon.stop()
    elif 'restart' == sys.argv[1]:
        daemon.restart()
    elif 'foreground' == sys.argv[1]: #This runs the daemon in the foreground
        daemon.run()
    else:
        print "Unknown command"
        sys.exit(2)
    sys.exit(0)
else:
    print "usage: %s start|foreground|stop|restart" % sys.argv[0]
    sys.exit(2)

Answer 1

GELÖST . Ich hatte den Eindruck, dass die foreground und die start Parameter waren zwei verschiedene Dinge. Es stellte sich heraus, dass ich nur das Folgende tun musste.

def run(self):
    while True:
        time.sleep(2)

zu

def start(self):
    while True:
        time.sleep(2)

Ich habe dann die foreground Parameter, denn ich kann das Skript vom Terminal aus mit dem start Befehl, um die Ausgabe im Vordergrund zu sehen.

python /opt/my-daemon.py start

Auch in rc.local Ich starte das Skript wie folgt:

python /opt/my-daemon.py start &

Dies versteckt den Daemon-Prozess und führt das Skript beim Start aus, unabhängig davon, welcher Benutzer sich anmeldet :)

Answer 2

Anstatt daemon.py zu verwenden, können Sie auch Ubuntu's Upstart-System die eine einfache Möglichkeit bietet, einen Respawning-Daemon einzurichten. Aus dem gleichen Link, es Funktionen:

* Services may be respawned if they die unexpectedly
* Supervision and respawning of daemons which separate from their parent process

Wenn Sie Ubuntu 9.10 oder höher verwenden, sehen Sie sich als Beispiel /etc/init/cron.conf an. Bei früheren Ubuntu-Versionen befinden sich die Startskripte meines Wissens nach in /etc/event.d/.

Für eine Erläuterung der Upstart-Schlüsselwörter, siehe ici .

Answer 3

Versuchen Sie dies http://gunslingerc0de.wordpress.com/2010/03/02/forking-daemon-process-in-unix/