9bb945f0ed7d1ff20625f2017487fdc4d9878f25
[python-daemon.git] / src / daemon.py
1 # -*- coding: utf-8 -*-
2
3 # Public Domain
4 #
5 # Copyright 2007, 2009 Sander Marechal <s.marechal@jejik.com>
6 # Copyright 2010, 2011 Jack Kaliko <efrim@azylum.org>
7 #
8 # http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/
9
10 import atexit
11 import os
12 import sys
13 import time
14 from signal import signal, SIGTERM
15
16
17 class Daemon(object):
18     """
19     A generic daemon class.
20
21     Usage: subclass the Daemon class and override the run() method
22     """
23     version = "0.2"
24
25     def __init__(self, pidfile,
26             stdin='/dev/null',
27             stdout='/dev/null',
28             stderr='/dev/null'):
29         self.stdin = stdin
30         self.stdout = stdout
31         self.stderr = stderr
32         self.pidfile = pidfile
33         self.umask = 0
34
35     def daemonize(self):
36         """
37         do the UNIX double-fork magic, see Stevens' "Advanced
38         Programming in the UNIX Environment" for details (ISBN 0201563177)
39         http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
40         """
41         try:
42             pid = os.fork()
43             if pid > 0:
44                 # exit first parent
45                 sys.exit(0)
46         except OSError, e:
47             sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
48             sys.exit(1)
49
50         # Decouple from parent environment
51         os.chdir("/")
52         os.setsid()
53         self.umask = os.umask(0)
54
55         # Do second fork
56         try:
57             pid = os.fork()
58             if pid > 0:
59                 # exit from second parent
60                 sys.exit(0)
61         except OSError, e:
62             sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
63             sys.exit(1)
64
65         self.write_pid()
66         # redirect standard file descriptors
67         sys.stdout.flush()
68         sys.stderr.flush()
69         si = file(self.stdin, 'r')
70         so = file(self.stdout, 'a+')
71         se = file(self.stderr, 'a+', 0)
72         os.dup2(si.fileno(), sys.stdin.fileno())
73         os.dup2(so.fileno(), sys.stdout.fileno())
74         os.dup2(se.fileno(), sys.stderr.fileno())
75
76         atexit.register(self.shutdown)
77         self.signal_management()
78
79     def write_pid(self):
80         # write pidfile
81         if not self.pidfile:
82             return
83         pid = str(os.getpid())
84         try:
85             os.umask(self.umask)
86             file(self.pidfile, 'w').write('%s\n' % pid)
87             #except IOError, wpid_err:
88         except Exception, wpid_err:
89             sys.stderr.write(u'Error trying to write pid file to %s: %s\n' %
90                    (unicode(self.pidfile, 'utf-8'), wpid_err))
91             sys.exit(1)
92         os.umask(0)
93         atexit.register(self.delpid)
94
95     def signal_management(self):
96         # Declare signal handlers
97         signal(SIGTERM, self.exit_handler)
98
99     def exit_handler(self, signum, frame):
100         sys.exit(1)
101
102     def delpid(self):
103         os.unlink(self.pidfile)
104
105     def start(self):
106         """
107         Start the daemon
108         """
109         # Check for a pidfile to see if the daemon already runs
110         try:
111             pf = file(self.pidfile, 'r')
112             pid = int(pf.read().strip())
113             pf.close()
114         except IOError:
115             pid = None
116
117         if pid:
118             message = "pidfile %s already exist. Daemon already running?\n"
119             sys.stderr.write(message % self.pidfile)
120             sys.exit(1)
121
122         # Start the daemon
123         self.daemonize()
124         self.run()
125
126     def foreground(self):
127         """
128         Foreground/debug mode
129         """
130         self.write_pid()
131         atexit.register(self.shutdown)
132         self.run()
133
134     def stop(self):
135         """
136         Stop the daemon
137         """
138         # Get the pid from the pidfile
139         try:
140             pf = file(self.pidfile, 'r')
141             pid = int(pf.read().strip())
142             pf.close()
143         except IOError:
144             pid = None
145
146         if not pid:
147             message = "pidfile %s does not exist. Daemon not running?\n"
148             sys.stderr.write(message % self.pidfile)
149             return  # not an error in a restart
150
151         # Try killing the daemon process
152         try:
153             os.kill(pid, SIGTERM)
154             time.sleep(0.1)
155         except OSError, err:
156             err = str(err)
157             if err.find("No such process") > 0:
158                 if os.path.exists(self.pidfile):
159                     message = "Daemon not running? removing pid file %s.\n"
160                     sys.stderr.write(message % self.pidfile)
161                     os.remove(self.pidfile)
162             else:
163                 print str(err)
164                 sys.exit(1)
165
166     def restart(self):
167         """
168         Restart the daemon
169         """
170         self.stop()
171         self.start()
172
173     def shutdown(self):
174         """
175         You should override this method when you subclass Daemon. It will be
176         called when the process is being stopped.
177         Pay attention:
178         Daemon() uses atexit to call Daemon().shutdown(), as a consequence
179         shutdown and any other functions registered via this module are not
180         called when the program is killed by an un-handled/unknown signal.
181         This is the reason of Daemon().signal_management() existence.
182         """
183
184     def run(self):
185         """
186         You should override this method when you subclass Daemon. It will be
187         called after the process has been daemonized by start() or restart().
188         """
189
190
191 def main():
192     pass
193
194 # Script starts here
195 if __name__ == '__main__':
196     main()
197
198 # VIM MODLINE
199 # vim: ai ts=4 sw=4 sts=4 expandtab