1 # Copyright (c) 2010 Nicira Networks
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:
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
25 import ovs.fatal_signal
28 import ovs.socket_util
32 # --detach: Should we run in the background?
35 # --pidfile: Name of pidfile (null if none).
38 # Our pidfile's inode and device, if we have created one.
42 # --overwrite-pidfile: Create pidfile even if one already exists and is locked?
43 _overwrite_pidfile = False
45 # --no-chdir: Should we chdir to "/"?
48 # --monitor: Should a supervisory process monitor the daemon and restart it if
49 # it dies due to an error signal?
52 # File descriptor used by daemonize_start() and daemonize_complete().
57 def make_pidfile_name(name):
58 """Returns the file name that would be used for a pidfile if 'name' were
59 provided to set_pidfile()."""
60 if name is None or name == "":
61 return "%s/%s.pid" % (ovs.dirs.RUNDIR, ovs.util.PROGRAM_NAME)
63 return ovs.util.abs_file_name(ovs.dirs.RUNDIR, name)
65 def set_pidfile(name):
66 """Sets up a following call to daemonize() to create a pidfile named
67 'name'. If 'name' begins with '/', then it is treated as an absolute path.
68 Otherwise, it is taken relative to ovs.util.RUNDIR, which is
69 $(prefix)/var/run by default.
71 If 'name' is null, then ovs.util.PROGRAM_NAME followed by ".pid" is
74 _pidfile = make_pidfile_name(name)
77 """Returns an absolute path to the configured pidfile, or None if no
78 pidfile is configured. The caller must not modify or free the returned
83 """Sets that we do not chdir to "/"."""
87 def is_chdir_enabled():
88 """Will we chdir to "/" as part of daemonizing?"""
91 def ignore_existing_pidfile():
92 """Normally, die_if_already_running() will terminate the program with a
93 message if a locked pidfile already exists. If this function is called,
94 die_if_already_running() will merely log a warning."""
95 global _overwrite_pidfile
96 _overwrite_pidfile = True
99 """Sets up a following call to daemonize() to detach from the foreground
100 session, running this process in the background."""
105 """Will daemonize() really detach?"""
109 """Sets up a following call to daemonize() to fork a supervisory process to
110 monitor the daemon and restart it if it dies due to an error signal."""
114 def _already_running():
115 """If a pidfile has been configured and that pidfile already exists and is
116 locked by a running process, returns True. Otherwise, returns False."""
117 if _pidfile is not None:
119 file = open(_pidfile, "r+")
122 fcntl.lockf(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
124 if e.errno in [errno.EACCES, errno.EAGAIN]:
126 logging.error("error locking %s (%s)"
127 % (_pidfile, os.strerror(e.errno)))
130 # This releases the lock, which we don't really want.
133 if e.errno == errno.ENOENT:
135 logging.error("error opening %s (%s)"
136 % (_pidfile, os.strerror(e.errno)))
139 def die_if_already_running():
140 """If a locked pidfile exists, issue a warning message and, unless
141 ignore_existing_pidfile() has been called, terminate the program."""
142 if _already_running():
143 if not _overwrite_pidfile:
144 sys.stderr.write("%s: already running\n" % get_pidfile())
147 logging.warn("%s: %s already running"
148 % (get_pidfile(), ovs.util.PROGRAM_NAME))
151 """If a pidfile has been configured, creates it and stores the running
152 process's pid in it. Ensures that the pidfile will be deleted when the
154 if _pidfile is not None:
155 # Create pidfile via temporary file, so that observers never see an
156 # empty pidfile or an unlocked pidfile.
158 tmpfile = "%s.tmp%d" % (_pidfile, pid)
159 ovs.fatal_signal.add_file_to_unlink(tmpfile)
162 # This is global to keep Python from garbage-collecting and
163 # therefore closing our file after this function exits. That would
164 # unlock the lock for us, and we don't want that.
167 file = open(tmpfile, "w")
169 logging.error("%s: create failed: %s"
170 % (tmpfile, os.strerror(e.errno)))
174 fcntl.lockf(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
176 logging.error("%s: fcntl failed: %s"
177 % (tmpfile, os.strerror(e.errno)))
182 file.write("%s\n" % pid)
184 ovs.fatal_signal.add_file_to_unlink(_pidfile)
186 logging.error("%s: write failed: %s"
187 % (tmpfile, os.strerror(e.errno)))
192 os.rename(tmpfile, _pidfile)
194 ovs.fatal_signal.remove_file_to_unlink(_pidfile)
195 logging.error("failed to rename \"%s\" to \"%s\": %s"
196 % (tmpfile, _pidfile, os.strerror(e.errno)))
200 s = os.fstat(file.fileno())
201 _pidfile_dev = s.st_dev
202 _pidfile_ino = s.st_ino
205 """If configured with set_pidfile() or set_detach(), creates the pid file
206 and detaches from the foreground session."""
210 def _waitpid(pid, options):
213 return os.waitpid(pid, options)
215 if e.errno == errno.EINTR:
219 def _fork_and_wait_for_startup():
223 sys.stderr.write("pipe failed: %s\n" % os.strerror(e.errno))
229 sys.stderr.write("could not fork: %s\n" % os.strerror(e.errno))
233 # Running in parent process.
235 ovs.fatal_signal.fork()
241 retval, status = _waitpid(pid, 0)
242 if (retval == pid and
243 os.WIFEXITED(status) and os.WEXITSTATUS(status)):
244 # Child exited with an error. Convey the same error to
245 # our parent process as a courtesy.
246 sys.exit(os.WEXITSTATUS(status))
248 sys.stderr.write("fork child failed to signal startup\n")
253 # Running in parent process.
255 ovs.timeval.postfork()
256 #ovs.lockfile.postfork()
262 def _fork_notify_startup(fd):
264 error, bytes_written = ovs.socket_util.write_fully(fd, "0")
266 sys.stderr.write("could not write to pipe\n")
270 def _should_restart(status):
271 global RESTART_EXIT_CODE
273 if os.WIFEXITED(status) and os.WEXITSTATUS(status) == RESTART_EXIT_CODE:
276 if os.WIFSIGNALED(status):
277 for signame in ("SIGABRT", "SIGALRM", "SIGBUS", "SIGFPE", "SIGILL",
278 "SIGPIPE", "SIGSEGV", "SIGXCPU", "SIGXFSZ"):
279 if (signame in signal.__dict__ and
280 os.WTERMSIG(status) == signal.__dict__[signame]):
284 def _monitor_daemon(daemon_pid):
285 # XXX should log daemon's stderr output at startup time
286 # XXX should use setproctitle module if available
289 retval, status = _waitpid(daemon_pid, 0)
291 sys.stderr.write("waitpid failed\n")
293 elif retval == daemon_pid:
294 status_msg = ("pid %d died, %s"
295 % (daemon_pid, ovs.process.status_msg(status)))
297 if _should_restart(status):
298 if os.WCOREDUMP(status):
299 # Disable further core dumps to save disk space.
301 resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
302 except resource.error:
303 logging.warning("failed to disable core dumps")
305 # Throttle restarts to no more than once every 10 seconds.
306 if (last_restart is not None and
307 ovs.timeval.msec() < last_restart + 10000):
308 logging.warning("%s, waiting until 10 seconds since last "
309 "restart" % status_msg)
311 now = ovs.timeval.msec()
312 wakeup = last_restart + 10000
315 print "sleep %f" % ((wakeup - now) / 1000.0)
316 time.sleep((wakeup - now) / 1000.0)
317 last_restart = ovs.timeval.msec()
319 logging.error("%s, restarting" % status_msg)
320 daemon_pid = _fork_and_wait_for_startup()
324 logging.info("%s, exiting" % status_msg)
327 # Running in new daemon process.
329 def _close_standard_fds():
330 """Close stdin, stdout, stderr. If we're started from e.g. an SSH session,
331 then this keeps us from holding that session open artificially."""
332 null_fd = ovs.socket_util.get_null_fd()
338 def daemonize_start():
339 """If daemonization is configured, then starts daemonization, by forking
340 and returning in the child process. The parent process hangs around until
341 the child lets it know either that it completed startup successfully (by
342 calling daemon_complete()) or that it failed to start up (by exiting with a
343 nonzero exit code)."""
346 if _fork_and_wait_for_startup() > 0:
347 # Running in parent process.
349 # Running in daemon or monitor process.
352 saved_daemonize_fd = _daemonize_fd
353 daemon_pid = _fork_and_wait_for_startup()
355 # Running in monitor process.
356 _fork_notify_startup(saved_daemonize_fd)
357 _close_standard_fds()
358 _monitor_daemon(daemon_pid)
359 # Running in daemon process
363 def daemonize_complete():
364 """If daemonization is configured, then this function notifies the parent
365 process that the child process has completed startup successfully."""
366 _fork_notify_startup(_daemonize_fd)
372 _close_standard_fds()
377 --detach run in background as daemon
378 --no-chdir do not chdir to '/'
379 --pidfile[=FILE] create pidfile (default: %s/%s.pid)
380 --overwrite-pidfile with --pidfile, start even if already running
381 """ % (ovs.dirs.RUNDIR, ovs.util.PROGRAM_NAME))
383 def read_pidfile(pidfile):
384 """Opens and reads a PID from 'pidfile'. Returns the nonnegative PID if
385 successful, otherwise a negative errno value."""
386 if _pidfile_dev is not None:
389 if s.st_ino == _pidfile_ino and s.st_dev == _pidfile_dev:
390 # It's our own pidfile. We can't afford to open it,
391 # because closing *any* fd for a file that a process
392 # has locked also releases all the locks on that file.
394 # Fortunately, we know the associated pid anyhow.
400 file = open(pidfile, "r")
402 logging.warning("%s: open: %s" % (pidfile, os.strerror(e.errno)))
405 # Python fcntl doesn't directly support F_GETLK so we have to just try
406 # to lock it. If we get a conflicting lock that's "success"; otherwise
407 # the file is not locked.
409 fcntl.lockf(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
410 # File isn't locked if we get here, so treat that as an error.
411 logging.warning("%s: pid file is not locked" % pidfile)
413 # As a side effect, this drops the lock.
419 if e.errno not in [errno.EACCES, errno.EAGAIN]:
420 logging.warn("%s: fcntl: %s" % (pidfile, os.strerror(e.errno)))
425 return int(file.readline())
427 logging.warning("%s: read: %s" % (pidfile, e.strerror))
430 logging.warning("%s does not contain a pid" % pidfile)
438 # XXX Python's getopt does not support options with optional arguments, so we
439 # have to separate --pidfile (with no argument) from --pidfile-name (with an
440 # argument). Need to write our own getopt I guess.
441 LONG_OPTIONS = ["detach", "no-chdir", "pidfile", "pidfile-name=",
442 "overwrite-pidfile", "monitor"]
444 def parse_opt(option, arg):
445 if option == '--detach':
447 elif option == '--no-chdir':
449 elif option == '--pidfile':
451 elif option == '--pidfile-name':
453 elif option == '--overwrite-pidfile':
454 ignore_existing_pidfile()
455 elif option == '--monitor':