xdai-monocle 0.8.1

安装

通过pip安装

pip install daemonocle

或下载源代码并手动安装

git clone https://github.com/jnrbsn/daemonocle.git
cd daemonocle/
python setup.py install

基本用法

这里有一个 非常非常 基本示例

import sys
import time

import daemonocle

# This is your daemon. It sleeps, and then sleeps again.
def main():
    while True:
        time.sleep(10)

if __name__ == '__main__':
    daemon = daemonocle.Daemon(
        worker=main,
        pidfile='/var/run/daemonocle_example.pid',
    )
    daemon.do_action(sys.argv[1])

这里有一个带有日志和 关闭回调 的相同示例

import logging
import sys
import time

import daemonocle

def cb_shutdown(message, code):
    logging.info('Daemon is stopping')
    logging.debug(message)

def main():
    logging.basicConfig(
        filename='/var/log/daemonocle_example.log',
        level=logging.DEBUG, format='%(asctime)s [%(levelname)s] %(message)s',
    )
    logging.info('Daemon is starting')
    while True:
        logging.debug('Still running')
        time.sleep(10)

if __name__ == '__main__':
    daemon = daemonocle.Daemon(
        worker=main,
        shutdown_callback=cb_shutdown,
        pidfile='/var/run/daemonocle_example.pid',
    )
    daemon.do_action(sys.argv[1])

运行时的样子如下

user@host:~$ python example.py start
Starting example.py ... OK
user@host:~$ python example.py status
example.py -- pid: 1234, status: running, uptime: 1m, %cpu: 0.0, %mem: 0.0
user@host:~$ python example.py stop
Stopping example.py ... OK
user@host:~$ cat /var/log/daemonocle_example.log
2014-05-04 12:39:21,090 [INFO] Daemon is starting
2014-05-04 12:39:21,091 [DEBUG] Still running
2014-05-04 12:39:31,091 [DEBUG] Still running
2014-05-04 12:39:41,091 [DEBUG] Still running
2014-05-04 12:39:51,093 [DEBUG] Still running
2014-05-04 12:40:01,094 [DEBUG] Still running
2014-05-04 12:40:07,113 [INFO] Daemon is stopping
2014-05-04 12:40:07,114 [DEBUG] Terminated by SIGTERM (15)

有关更多详细信息，请参阅下面的 详细用法 部分。

原因

如果你仔细想想，很多Unix守护进程其实根本不知道自己在做什么。你是否曾经遇到过类似这种情况？

user@host:~$ sudo example start
starting example ... ok
user@host:~$ ps aux | grep example
user      1234  0.0  0.0   1234  1234 pts/1    S+   12:34   0:00 grep example
user@host:~$ sudo example start
starting example ... ok
user@host:~$ echo $?
0
user@host:~$ tail -f /var/log/example.log
...

或者类似这种情况？

user@host:~$ sudo example stop
stopping example ... ok
user@host:~$ ps aux | grep example
user       123  0.0  0.0   1234  1234 ?        Ss   00:00   0:00 /usr/local/bin/example
user      1234  0.0  0.0   1234  1234 pts/1    S+   12:34   0:00 grep example
user@host:~$ sudo example stop
stopping example ... ok
user@host:~$ ps aux | grep example
user       123  0.0  0.0   1234  1234 ?        Ss   00:00   0:00 /usr/local/bin/example
user      1240  0.0  0.0   1234  1234 pts/1    S+   12:34   0:00 grep example
user@host:~$ sudo kill -9 123
...

或者类似这种情况？

user@host:~$ sudo example status
Usage: example {start|stop|restart}
user@host:~$ ps aux | grep example
...

这些都是一些常见问题的例子。其实不必如此。

注意：你可能正在想，“为什么不写一个更智能的启动/停止shell脚本包装器，检查守护进程是否真的启动了，真的停止了等等？” 真的吗？ 其实不必如此。 我认为守护进程应该更有自我意识。它们应该大部分时间自己处理问题，你的启动/停止脚本应该只围绕你的守护进程是一个非常薄的包装器，或者简单地指向你的守护进程的符号链接。

user@host:~$ python example.py status
example.py -- pid: 1234, status: running, uptime: 12d 3h 4m, %cpu: 12.4, %mem: 4.5

import os
import sys
import time

import daemonocle

class FileWatcher(object):

    def __init__(self, filename, daemon):
        self._filename = filename
        self._daemon = daemon
        self._file_mtime = os.stat(self._filename).st_mtime

    def file_has_changed(self):
        current_mtime = os.stat(self._filename).st_mtime
        if current_mtime != self._file_mtime:
            self._file_mtime = current_mtime
            return True
        return False

    def watch(self):
        while True:
            if self.file_has_changed():
                self._daemon.reload()
            time.sleep(1)

if __name__ == '__main__':
    daemon = daemonocle.Daemon(pidfile='/var/run/daemonocle_example.pid')
    fw = FileWatcher(filename='/etc/daemonocle_example.conf', daemon=daemon)
    daemon.worker = fw.watch
    daemon.do_action(sys.argv[1])

详细用法

daemonocle.Daemon类是使用daemonocle创建守护进程的主要类。以下是类的构造函数签名：

class daemonocle.Daemon(
    worker=None, shutdown_callback=None, prog=None, pidfile=None, detach=True,
    uid=None, gid=None, workdir='/', chrootdir=None, umask=022, stop_timeout=10,
    close_open_files=False)

以下是所有参数的描述：

worker

执行您守护进程所有工作的函数。

shutdown_callback

该函数将在守护进程关闭时被调用。它应接受一个 message 和一个 code 参数。消息是一个可读的消息，解释了守护进程为何关闭。记录此消息可能很有用。代码是它打算退出的退出码。有关更多详细信息，请参阅 关闭回调。

prog

用于输出消息的程序名称。默认值：os.path.basename(sys.argv[0])

pidfile

要使用的 PID 文件路径。不使用 PID 文件不是必需的，但如果您不这样做，您将无法使用您可能期望的所有功能。请确保运行守护进程的用户有权写入该文件的目录。

detach

是否从终端分离并进入后台。有关更多详细信息，请参阅 非分离模式。默认值：True

uid

守护进程启动时要切换到的用户 ID。默认情况下不切换用户。

gid

守护进程启动时要切换到的组 ID。默认情况下不切换组。

workdir

守护进程启动时要更改到的目录路径。请注意，如果进程的工作目录在该文件系统上，则无法卸载文件系统。因此，如果您更改了默认值，请务必小心更改。默认值："/"

chrootdir

守护进程启动时要设置为有效根目录的目录路径。默认情况下不执行任何操作。

umask

进程的文件创建掩码（“umask”）。默认值：022

stop_timeout

在抛出错误之前等待守护进程停止的秒数。默认值：10

close_open_files

守护进程分离时是否关闭所有打开的文件。默认值：False

import daemonocle

class MyDaemon(daemonocle.Daemon):

    @daemonocle.expose_action
    def full_status(self):
        """Get more detailed status of the daemon."""
        pass

import time

import click
from daemonocle.cli import DaemonCLI

@click.command(cls=DaemonCLI, daemon_params={'pidfile': '/var/run/example.pid'})
def main():
    """This is my awesome daemon. It pretends to do work in the background."""
    while True:
        time.sleep(10)

if __name__ == '__main__':
    main()

user@host:~$ python example.py --help
Usage: example.py [<options>] <command> [<args>]...

  This is my awesome daemon. It pretends to do work in the background.

Options:
  --help  Show this message and exit.

Commands:
  start    Start the daemon.
  stop     Stop the daemon.
  restart  Stop then start the daemon.
  status   Get the status of the daemon.
user@host:~$ python example.py start --help
Usage: example.py start [<options>]

  Start the daemon.

Options:
  --debug  Do NOT detach and run in the background.
  --help   Show this message and exit.

错误、请求、问题等。

请在GitHub上创建一个问题。