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 system而不是使用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关键字的说明，请参阅here。

Answer 3

您可以尝试此http://gunslingerc0de.wordpress.com/2010/03/02/forking-daemon-process-in-unix/

Python守护进程不会在Ubuntu的后台运行

3 个答案: