我使用这代码来守护我的应用程序。它允许您使用以下命令 start / stop / restart 脚本。

  python myscript.py start 
 python myscript.py stop 
 python myscript.py restart 
 

除此之外，我还有一个 init.d 脚本，用于控制我的服务。这允许您在操作系统启动时自动启动服务。

这是一个简单的例子，让你的去。只需在类中移动你的代码，并从运行$ c>函数 MyDeamon 中调用它。

  import sys 
导入时间

从守护程序导入守护程序


 class YourCode（object）：
 def run（self）：
 while True：
 time.sleep（1）


类MyDaemon ：
 def run（self）：
＃或者只是将您的代码与MyDaemon合并。 
 your_code = YourCode（）
 your_code.run（）


如果__name__ ==__main__：
 daemon = MyDaemon daemon-example.pid'）
如果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 
 else：
 print未知命令
 sys.exit（2）
 sys.exit（0）
 else：
 printusage： s start | stop | restart％sys.argv [0] 
 sys.exit（2）
 

Upstart

如果您运行的操作系统使用Upstart（例如CentOS 6），您还可以使用Upstart管理服务。如果你使用Upstart，你可以保持你的脚本，只需在 /etc/init/my-service.conf

下添加类似的东西

开始启动sshd
stop on runlevel [！2345]

exec / usr / bin / python / opt / my_service .py
respawn


然后可以使用start / stop / restart管理您的服务。

例如

  start my-service 
 -service 
 restart my-service 
 

使用upstart的更详细的示例可用此处。

系统

如果您运行的操作系统使用Systemd（例如CentOS 7），您可以查看以下 *** answer 。

I want to run a python script in a CENTOS server:

#!/usr/bin/env python
import socket
try:    
    import thread 
except ImportError:
    import _thread as thread #Py3K changed it.
class Polserv(object):
    def __init__(self):
        self.numthreads = 0
        self.tidcount   = 0
        self.port       = 843
        self.sock       = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.sock.bind(('100.100.100.100', self.port))
        self.sock.listen(5)
    def run(self):
        while True:
            thread.start_new_thread(self.handle, self.sock.accept()) 
    def handle(self,conn,addr):
        self.numthreads += 1
        self.tidcount   += 1
        tid=self.tidcount
        while True:
            data=conn.recv(2048)
            if not data:
                conn.close()
                self.numthreads-=1
                break
            #if "<policy-file-request/>\0" in data:
            conn.sendall(b"<?xml version='1.0'?><cross-domain-policy><allow-access-from domain='*' to-ports='*'/></cross-domain-policy>")
            conn.close()
            self.numthreads-=1
            break
        #conn.sendall(b"[#%d (%d running)] %s" % (tid,self.numthreads,data) )
Polserv().run()

Im using $ python flashpolicyd.py and it works fine... The question is: How to keep this script running even after I close the ssh console?

I use this code to daemonize my applications. It allows you start/stop/restart the script using the following commands.

python myscript.py start
python myscript.py stop
python myscript.py restart

In addition to this I also have an init.d script for controlling my service. This allows you to automatically start the service when your operating system boots-up.

Here is a simple example to get your going. Simply move your code inside a class, and call it from the run function inside MyDeamon.

import sys
import time

from daemon import Daemon


class YourCode(object):
    def run(self):
        while True:
            time.sleep(1)


class MyDaemon(Daemon):
    def run(self):
        # Or simply merge your code with MyDaemon.
        your_code = YourCode()
        your_code.run()


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()
        else:
            print "Unknown command"
            sys.exit(2)
        sys.exit(0)
    else:
        print "usage: %s start|stop|restart" % sys.argv[0]
        sys.exit(2)

Upstart

If you are running an operating system that is using Upstart (e.g. CentOS 6) - you can also use Upstart to manage the service. If you use Upstart you can keep your script as is, and simply add something like this under /etc/init/my-service.conf

start on started sshd
stop on runlevel [!2345]

exec /usr/bin/python /opt/my_service.py
respawn

You can then use start/stop/restart to manage your service.

e.g.

start my-service
stop my-service
restart my-service

A more detailed example of working with upstart is available here.

Systemd

If you are running an operating system that uses Systemd (e.g. CentOS 7) you can take a look at the following *** answer.