tunneling: Reduce priority of multicast tunnels.
[openvswitch] / python / ovs / daemon.py
1 # Copyright (c) 2010, 2011 Nicira Networks
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at:
6 #
7 #     http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14
15 import errno
16 import fcntl
17 import os
18 import resource
19 import signal
20 import sys
21 import time
22
23 import ovs.dirs
24 import ovs.fatal_signal
25 #import ovs.lockfile
26 import ovs.process
27 import ovs.socket_util
28 import ovs.timeval
29 import ovs.util
30 import ovs.vlog
31
32 vlog = ovs.vlog.Vlog("daemon")
33
34 # --detach: Should we run in the background?
35 _detach = False
36
37 # --pidfile: Name of pidfile (null if none).
38 _pidfile = None
39
40 # Our pidfile's inode and device, if we have created one.
41 _pidfile_dev = None
42 _pidfile_ino = None
43
44 # --overwrite-pidfile: Create pidfile even if one already exists and is locked?
45 _overwrite_pidfile = False
46
47 # --no-chdir: Should we chdir to "/"?
48 _chdir = True
49
50 # --monitor: Should a supervisory process monitor the daemon and restart it if
51 # it dies due to an error signal?
52 _monitor = False
53
54 # File descriptor used by daemonize_start() and daemonize_complete().
55 _daemonize_fd = None
56
57 RESTART_EXIT_CODE = 5
58
59
60 def make_pidfile_name(name):
61     """Returns the file name that would be used for a pidfile if 'name' were
62     provided to set_pidfile()."""
63     if name is None or name == "":
64         return "%s/%s.pid" % (ovs.dirs.RUNDIR, ovs.util.PROGRAM_NAME)
65     else:
66         return ovs.util.abs_file_name(ovs.dirs.RUNDIR, name)
67
68
69 def set_pidfile(name):
70     """Sets up a following call to daemonize() to create a pidfile named
71     'name'.  If 'name' begins with '/', then it is treated as an absolute path.
72     Otherwise, it is taken relative to ovs.util.RUNDIR, which is
73     $(prefix)/var/run by default.
74
75     If 'name' is null, then ovs.util.PROGRAM_NAME followed by ".pid" is
76     used."""
77     global _pidfile
78     _pidfile = make_pidfile_name(name)
79
80
81 def get_pidfile():
82     """Returns an absolute path to the configured pidfile, or None if no
83     pidfile is configured."""
84     return _pidfile
85
86
87 def set_no_chdir():
88     """Sets that we do not chdir to "/"."""
89     global _chdir
90     _chdir = False
91
92
93 def is_chdir_enabled():
94     """Will we chdir to "/" as part of daemonizing?"""
95     return _chdir
96
97
98 def ignore_existing_pidfile():
99     """Normally, daemonize() or daemonize_start() will terminate the program
100     with a message if a locked pidfile already exists.  If this function is
101     called, an existing pidfile will be replaced, with a warning."""
102     global _overwrite_pidfile
103     _overwrite_pidfile = True
104
105
106 def set_detach():
107     """Sets up a following call to daemonize() to detach from the foreground
108     session, running this process in the background."""
109     global _detach
110     _detach = True
111
112
113 def get_detach():
114     """Will daemonize() really detach?"""
115     return _detach
116
117
118 def set_monitor():
119     """Sets up a following call to daemonize() to fork a supervisory process to
120     monitor the daemon and restart it if it dies due to an error signal."""
121     global _monitor
122     _monitor = True
123
124
125 def _fatal(msg):
126     vlog.err(msg)
127     sys.stderr.write("%s\n" % msg)
128     sys.exit(1)
129
130
131 def _make_pidfile():
132     """If a pidfile has been configured, creates it and stores the running
133     process's pid in it.  Ensures that the pidfile will be deleted when the
134     process exits."""
135     pid = os.getpid()
136
137     # Create a temporary pidfile.
138     tmpfile = "%s.tmp%d" % (_pidfile, pid)
139     ovs.fatal_signal.add_file_to_unlink(tmpfile)
140     try:
141         # This is global to keep Python from garbage-collecting and
142         # therefore closing our file after this function exits.  That would
143         # unlock the lock for us, and we don't want that.
144         global file_handle
145
146         file_handle = open(tmpfile, "w")
147     except IOError, e:
148         _fatal("%s: create failed (%s)" % (tmpfile, e.strerror))
149
150     try:
151         s = os.fstat(file_handle.fileno())
152     except IOError, e:
153         _fatal("%s: fstat failed (%s)" % (tmpfile, e.strerror))
154
155     try:
156         file_handle.write("%s\n" % pid)
157         file_handle.flush()
158     except OSError, e:
159         _fatal("%s: write failed: %s" % (tmpfile, e.strerror))
160
161     try:
162         fcntl.lockf(file_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
163     except IOError, e:
164         _fatal("%s: fcntl failed: %s" % (tmpfile, e.strerror))
165
166     # Rename or link it to the correct name.
167     if _overwrite_pidfile:
168         try:
169             os.rename(tmpfile, _pidfile)
170         except OSError, e:
171             _fatal("failed to rename \"%s\" to \"%s\" (%s)"
172                    % (tmpfile, _pidfile, e.strerror))
173     else:
174         while True:
175             try:
176                 os.link(tmpfile, _pidfile)
177                 error = 0
178             except OSError, e:
179                 error = e.errno
180             if error == errno.EEXIST:
181                 _check_already_running()
182             elif error != errno.EINTR:
183                 break
184         if error:
185             _fatal("failed to link \"%s\" as \"%s\" (%s)"
186                    % (tmpfile, _pidfile, os.strerror(error)))
187
188     # Ensure that the pidfile will get deleted on exit.
189     ovs.fatal_signal.add_file_to_unlink(_pidfile)
190
191     # Delete the temporary pidfile if it still exists.
192     if not _overwrite_pidfile:
193         error = ovs.fatal_signal.unlink_file_now(tmpfile)
194         if error:
195             _fatal("%s: unlink failed (%s)" % (tmpfile, os.strerror(error)))
196
197     global _pidfile_dev
198     global _pidfile_ino
199     _pidfile_dev = s.st_dev
200     _pidfile_ino = s.st_ino
201
202
203 def daemonize():
204     """If configured with set_pidfile() or set_detach(), creates the pid file
205     and detaches from the foreground session."""
206     daemonize_start()
207     daemonize_complete()
208
209
210 def _waitpid(pid, options):
211     while True:
212         try:
213             return os.waitpid(pid, options)
214         except OSError, e:
215             if e.errno == errno.EINTR:
216                 pass
217             return -e.errno, 0
218
219
220 def _fork_and_wait_for_startup():
221     try:
222         rfd, wfd = os.pipe()
223     except OSError, e:
224         sys.stderr.write("pipe failed: %s\n" % os.strerror(e.errno))
225         sys.exit(1)
226
227     try:
228         pid = os.fork()
229     except OSError, e:
230         sys.stderr.write("could not fork: %s\n" % os.strerror(e.errno))
231         sys.exit(1)
232
233     if pid > 0:
234         # Running in parent process.
235         os.close(wfd)
236         ovs.fatal_signal.fork()
237         while True:
238             try:
239                 s = os.read(rfd, 1)
240                 error = 0
241             except OSError, e:
242                 s = ""
243                 error = e.errno
244             if error != errno.EINTR:
245                 break
246         if len(s) != 1:
247             retval, status = _waitpid(pid, 0)
248             if (retval == pid and
249                 os.WIFEXITED(status) and os.WEXITSTATUS(status)):
250                 # Child exited with an error.  Convey the same error to
251                 # our parent process as a courtesy.
252                 sys.exit(os.WEXITSTATUS(status))
253             else:
254                 sys.stderr.write("fork child failed to signal startup\n")
255                 sys.exit(1)
256
257         os.close(rfd)
258     else:
259         # Running in parent process.
260         os.close(rfd)
261         ovs.timeval.postfork()
262         #ovs.lockfile.postfork()
263
264         global _daemonize_fd
265         _daemonize_fd = wfd
266     return pid
267
268
269 def _fork_notify_startup(fd):
270     if fd is not None:
271         error, bytes_written = ovs.socket_util.write_fully(fd, "0")
272         if error:
273             sys.stderr.write("could not write to pipe\n")
274             sys.exit(1)
275         os.close(fd)
276
277
278 def _should_restart(status):
279     global RESTART_EXIT_CODE
280
281     if os.WIFEXITED(status) and os.WEXITSTATUS(status) == RESTART_EXIT_CODE:
282         return True
283
284     if os.WIFSIGNALED(status):
285         for signame in ("SIGABRT", "SIGALRM", "SIGBUS", "SIGFPE", "SIGILL",
286                         "SIGPIPE", "SIGSEGV", "SIGXCPU", "SIGXFSZ"):
287             if os.WTERMSIG(status) == getattr(signal, signame, None):
288                 return True
289     return False
290
291
292 def _monitor_daemon(daemon_pid):
293     # XXX should log daemon's stderr output at startup time
294     # XXX should use setproctitle module if available
295     last_restart = None
296     while True:
297         retval, status = _waitpid(daemon_pid, 0)
298         if retval < 0:
299             sys.stderr.write("waitpid failed\n")
300             sys.exit(1)
301         elif retval == daemon_pid:
302             status_msg = ("pid %d died, %s"
303                           % (daemon_pid, ovs.process.status_msg(status)))
304
305             if _should_restart(status):
306                 if os.WCOREDUMP(status):
307                     # Disable further core dumps to save disk space.
308                     try:
309                         resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
310                     except resource.error:
311                         vlog.warn("failed to disable core dumps")
312
313                 # Throttle restarts to no more than once every 10 seconds.
314                 if (last_restart is not None and
315                     ovs.timeval.msec() < last_restart + 10000):
316                     vlog.warn("%s, waiting until 10 seconds since last "
317                               "restart" % status_msg)
318                     while True:
319                         now = ovs.timeval.msec()
320                         wakeup = last_restart + 10000
321                         if now > wakeup:
322                             break
323                         print "sleep %f" % ((wakeup - now) / 1000.0)
324                         time.sleep((wakeup - now) / 1000.0)
325                 last_restart = ovs.timeval.msec()
326
327                 vlog.err("%s, restarting" % status_msg)
328                 daemon_pid = _fork_and_wait_for_startup()
329                 if not daemon_pid:
330                     break
331             else:
332                 vlog.info("%s, exiting" % status_msg)
333                 sys.exit(0)
334
335    # Running in new daemon process.
336
337
338 def _close_standard_fds():
339     """Close stdin, stdout, stderr.  If we're started from e.g. an SSH session,
340     then this keeps us from holding that session open artificially."""
341     null_fd = ovs.socket_util.get_null_fd()
342     if null_fd >= 0:
343         os.dup2(null_fd, 0)
344         os.dup2(null_fd, 1)
345         os.dup2(null_fd, 2)
346
347
348 def daemonize_start():
349     """If daemonization is configured, then starts daemonization, by forking
350     and returning in the child process.  The parent process hangs around until
351     the child lets it know either that it completed startup successfully (by
352     calling daemon_complete()) or that it failed to start up (by exiting with a
353     nonzero exit code)."""
354
355     if _detach:
356         if _fork_and_wait_for_startup() > 0:
357             # Running in parent process.
358             sys.exit(0)
359         # Running in daemon or monitor process.
360
361     if _monitor:
362         saved_daemonize_fd = _daemonize_fd
363         daemon_pid = _fork_and_wait_for_startup()
364         if daemon_pid > 0:
365             # Running in monitor process.
366             _fork_notify_startup(saved_daemonize_fd)
367             _close_standard_fds()
368             _monitor_daemon(daemon_pid)
369         # Running in daemon process
370
371     if _pidfile:
372         _make_pidfile()
373
374
375 def daemonize_complete():
376     """If daemonization is configured, then this function notifies the parent
377     process that the child process has completed startup successfully."""
378     _fork_notify_startup(_daemonize_fd)
379
380     if _detach:
381         os.setsid()
382         if _chdir:
383             os.chdir("/")
384         _close_standard_fds()
385
386
387 def usage():
388     sys.stdout.write("""
389 Daemon options:
390    --detach                run in background as daemon
391    --no-chdir              do not chdir to '/'
392    --pidfile[=FILE]        create pidfile (default: %s/%s.pid)
393    --overwrite-pidfile     with --pidfile, start even if already running
394 """ % (ovs.dirs.RUNDIR, ovs.util.PROGRAM_NAME))
395
396
397 def __read_pidfile(pidfile, delete_if_stale):
398     if _pidfile_dev is not None:
399         try:
400             s = os.stat(pidfile)
401             if s.st_ino == _pidfile_ino and s.st_dev == _pidfile_dev:
402                 # It's our own pidfile.  We can't afford to open it,
403                 # because closing *any* fd for a file that a process
404                 # has locked also releases all the locks on that file.
405                 #
406                 # Fortunately, we know the associated pid anyhow.
407                 return os.getpid()
408         except OSError:
409             pass
410
411     try:
412         file_handle = open(pidfile, "r+")
413     except IOError, e:
414         if e.errno == errno.ENOENT and delete_if_stale:
415             return 0
416         vlog.warn("%s: open: %s" % (pidfile, e.strerror))
417         return -e.errno
418
419     # Python fcntl doesn't directly support F_GETLK so we have to just try
420     # to lock it.
421     try:
422         fcntl.lockf(file_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
423
424         # pidfile exists but wasn't locked by anyone.  Now we have the lock.
425         if not delete_if_stale:
426             file_handle.close()
427             vlog.warn("%s: pid file is stale" % pidfile)
428             return -errno.ESRCH
429
430         # Is the file we have locked still named 'pidfile'?
431         try:
432             raced = False
433             s = os.stat(pidfile)
434             s2 = os.fstat(file_handle.fileno())
435             if s.st_ino != s2.st_ino or s.st_dev != s2.st_dev:
436                 raced = True
437         except IOError:
438             raced = True
439         if raced:
440             vlog.warn("%s: lost race to delete pidfile" % pidfile)
441             return -errno.EALREADY
442
443         # We won the right to delete the stale pidfile.
444         try:
445             os.unlink(pidfile)
446         except IOError, e:
447             vlog.warn("%s: failed to delete stale pidfile (%s)"
448                             % (pidfile, e.strerror))
449             return -e.errno
450         else:
451             vlog.dbg("%s: deleted stale pidfile" % pidfile)
452             file_handle.close()
453             return 0
454     except IOError, e:
455         if e.errno not in [errno.EACCES, errno.EAGAIN]:
456             vlog.warn("%s: fcntl: %s" % (pidfile, e.strerror))
457             return -e.errno
458
459     # Someone else has the pidfile locked.
460     try:
461         try:
462             error = int(file_handle.readline())
463         except IOError, e:
464             vlog.warn("%s: read: %s" % (pidfile, e.strerror))
465             error = -e.errno
466         except ValueError:
467             vlog.warn("%s does not contain a pid" % pidfile)
468             error = -errno.EINVAL
469
470         return error
471     finally:
472         try:
473             file_handle.close()
474         except IOError:
475             pass
476
477
478 def read_pidfile(pidfile):
479     """Opens and reads a PID from 'pidfile'.  Returns the positive PID if
480     successful, otherwise a negative errno value."""
481     return __read_pidfile(pidfile, False)
482
483
484 def _check_already_running():
485     pid = __read_pidfile(_pidfile, True)
486     if pid > 0:
487         _fatal("%s: already running as pid %d, aborting" % (_pidfile, pid))
488     elif pid < 0:
489         _fatal("%s: pidfile check failed (%s), aborting"
490                % (_pidfile, os.strerror(pid)))
491
492
493 def add_args(parser):
494     """Populates 'parser', an ArgumentParser allocated using the argparse
495     module, with the command line arguments required by the daemon module."""
496
497     pidfile = make_pidfile_name(None)
498
499     group = parser.add_argument_group(title="Daemon Options")
500     group.add_argument("--detach", action="store_true",
501             help="Run in background as a daemon.")
502     group.add_argument("--no-chdir", action="store_true",
503             help="Do not chdir to '/'.")
504     group.add_argument("--monitor", action="store_true",
505             help="Monitor %s process." % ovs.util.PROGRAM_NAME)
506     group.add_argument("--pidfile", nargs="?", const=pidfile,
507             help="Create pidfile (default %s)." % pidfile)
508     group.add_argument("--overwrite-pidfile", action="store_true",
509             help="With --pidfile, start even if already running.")
510
511
512 def handle_args(args):
513     """Handles daemon module settings in 'args'.  'args' is an object
514     containing values parsed by the parse_args() method of ArgumentParser.  The
515     parent ArgumentParser should have been prepared by add_args() before
516     calling parse_args()."""
517
518     if args.detach:
519         set_detach()
520
521     if args.no_chdir:
522         set_no_chdir()
523
524     if args.pidfile:
525         set_pidfile(args.pidfile)
526
527     if args.overwrite_pidfile:
528         ignore_existing_pidfile()
529
530     if args.monitor:
531         set_monitor()