Python守護進程不會在Ubuntu的后台運行

Question

我的Python守護進程在終端中使用此命令在我的Ubuntu系統的前台運行正常：

python /opt/my-daemon.py foreground

但是，當我嘗試使用“start”命令調用守護進程時，它會失敗，為什么？

python /opt/my-daemon.py start

這是我在/etc/rc.local文件中調用該命令的方法：

python /opt/my-daemon.py start &

這里的代碼：

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.my-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

解決了 。 我的印象是foreground和start參數是兩個不同的東西。 事實證明我只需要做以下事情。

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

至

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

然后我刪除了foreground參數，因為我可以使用start命令從終端運行腳本以查看前台的輸出。

python /opt/my-daemon.py start

另外，在rc.local我按如下方式啟動腳本：

python /opt/my-daemon.py start &

這會隱藏守護進程並在啟動時執行腳本，無論登錄的用戶是誰:)

Answer 2

您可能需要考慮利用Ubuntu的Upstart系統 ，而不是使用daemon.py，它提供了一種簡單的方法來設置重生守護進程。 從同一個鏈接，它的特點：

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

如果您使用的是Ubuntu9.10或更高版本，請查看/etc/init/cron.conf作為示例。 對於早期版本的Ubuntu，我相信upstart腳本位於/etc/event.d/中。

有關Upstart關鍵字的說明，請參閱此處 。

Answer 3

你可以嘗試這個http://gunslingerc0de.wordpress.com/2010/03/02/forking-daemon-process-in-unix/