Package ganeti :: Package utils :: Module process
[hide private]
[frames] | no frames]

Source Code for Module ganeti.utils.process

   1  # 
   2  # 
   3   
   4  # Copyright (C) 2006, 2007, 2010, 2011, 2012 Google Inc. 
   5  # 
   6  # This program is free software; you can redistribute it and/or modify 
   7  # it under the terms of the GNU General Public License as published by 
   8  # the Free Software Foundation; either version 2 of the License, or 
   9  # (at your option) any later version. 
  10  # 
  11  # This program is distributed in the hope that it will be useful, but 
  12  # WITHOUT ANY WARRANTY; without even the implied warranty of 
  13  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
  14  # General Public License for more details. 
  15  # 
  16  # You should have received a copy of the GNU General Public License 
  17  # along with this program; if not, write to the Free Software 
  18  # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 
  19  # 02110-1301, USA. 
  20   
  21  """Utility functions for processes. 
  22   
  23  """ 
  24   
  25   
  26  import os 
  27  import sys 
  28  import subprocess 
  29  import errno 
  30  import select 
  31  import logging 
  32  import signal 
  33  import resource 
  34   
  35  from cStringIO import StringIO 
  36   
  37  from ganeti import errors 
  38  from ganeti import constants 
  39  from ganeti import compat 
  40   
  41  from ganeti.utils import retry as utils_retry 
  42  from ganeti.utils import wrapper as utils_wrapper 
  43  from ganeti.utils import text as utils_text 
  44  from ganeti.utils import io as utils_io 
  45  from ganeti.utils import algo as utils_algo 
  46   
  47   
  48  #: when set to True, L{RunCmd} is disabled 
  49  _no_fork = False 
  50   
  51  (_TIMEOUT_NONE, 
  52   _TIMEOUT_TERM, 
  53   _TIMEOUT_KILL) = range(3) 
  54   
  55   
56 -def DisableFork():
57 """Disables the use of fork(2). 58 59 """ 60 global _no_fork # pylint: disable=W0603 61 62 _no_fork = True
63 64
65 -class RunResult(object):
66 """Holds the result of running external programs. 67 68 @type exit_code: int 69 @ivar exit_code: the exit code of the program, or None (if the program 70 didn't exit()) 71 @type signal: int or None 72 @ivar signal: the signal that caused the program to finish, or None 73 (if the program wasn't terminated by a signal) 74 @type stdout: str 75 @ivar stdout: the standard output of the program 76 @type stderr: str 77 @ivar stderr: the standard error of the program 78 @type failed: boolean 79 @ivar failed: True in case the program was 80 terminated by a signal or exited with a non-zero exit code 81 @ivar fail_reason: a string detailing the termination reason 82 83 """ 84 __slots__ = ["exit_code", "signal", "stdout", "stderr", 85 "failed", "fail_reason", "cmd"] 86
87 - def __init__(self, exit_code, signal_, stdout, stderr, cmd, timeout_action, 88 timeout):
89 self.cmd = cmd 90 self.exit_code = exit_code 91 self.signal = signal_ 92 self.stdout = stdout 93 self.stderr = stderr 94 self.failed = (signal_ is not None or exit_code != 0) 95 96 fail_msgs = [] 97 if self.signal is not None: 98 fail_msgs.append("terminated by signal %s" % self.signal) 99 elif self.exit_code is not None: 100 fail_msgs.append("exited with exit code %s" % self.exit_code) 101 else: 102 fail_msgs.append("unable to determine termination reason") 103 104 if timeout_action == _TIMEOUT_TERM: 105 fail_msgs.append("terminated after timeout of %.2f seconds" % timeout) 106 elif timeout_action == _TIMEOUT_KILL: 107 fail_msgs.append(("force termination after timeout of %.2f seconds" 108 " and linger for another %.2f seconds") % 109 (timeout, constants.CHILD_LINGER_TIMEOUT)) 110 111 if fail_msgs and self.failed: 112 self.fail_reason = utils_text.CommaJoin(fail_msgs) 113 else: 114 self.fail_reason = None 115 116 if self.failed: 117 logging.debug("Command '%s' failed (%s); output: %s", 118 self.cmd, self.fail_reason, self.output)
119
120 - def _GetOutput(self):
121 """Returns the combined stdout and stderr for easier usage. 122 123 """ 124 return self.stdout + self.stderr
125 126 output = property(_GetOutput, None, None, "Return full output")
127 128
129 -def _BuildCmdEnvironment(env, reset):
130 """Builds the environment for an external program. 131 132 """ 133 if reset: 134 cmd_env = {} 135 else: 136 cmd_env = os.environ.copy() 137 cmd_env["LC_ALL"] = "C" 138 139 if env is not None: 140 cmd_env.update(env) 141 142 return cmd_env
143 144
145 -def RunCmd(cmd, env=None, output=None, cwd="/", reset_env=False, 146 interactive=False, timeout=None, noclose_fds=None, 147 input_fd=None, postfork_fn=None):
148 """Execute a (shell) command. 149 150 The command should not read from its standard input, as it will be 151 closed. 152 153 @type cmd: string or list 154 @param cmd: Command to run 155 @type env: dict 156 @param env: Additional environment variables 157 @type output: str 158 @param output: if desired, the output of the command can be 159 saved in a file instead of the RunResult instance; this 160 parameter denotes the file name (if not None) 161 @type cwd: string 162 @param cwd: if specified, will be used as the working 163 directory for the command; the default will be / 164 @type reset_env: boolean 165 @param reset_env: whether to reset or keep the default os environment 166 @type interactive: boolean 167 @param interactive: whether we pipe stdin, stdout and stderr 168 (default behaviour) or run the command interactive 169 @type timeout: int 170 @param timeout: If not None, timeout in seconds until child process gets 171 killed 172 @type noclose_fds: list 173 @param noclose_fds: list of additional (fd >=3) file descriptors to leave 174 open for the child process 175 @type input_fd: C{file}-like object or numeric file descriptor 176 @param input_fd: File descriptor for process' standard input 177 @type postfork_fn: Callable receiving PID as parameter 178 @param postfork_fn: Callback run after fork but before timeout 179 @rtype: L{RunResult} 180 @return: RunResult instance 181 @raise errors.ProgrammerError: if we call this when forks are disabled 182 183 """ 184 if _no_fork: 185 raise errors.ProgrammerError("utils.RunCmd() called with fork() disabled") 186 187 if output and interactive: 188 raise errors.ProgrammerError("Parameters 'output' and 'interactive' can" 189 " not be provided at the same time") 190 191 if not (output is None or input_fd is None): 192 # The current logic in "_RunCmdFile", which is used when output is defined, 193 # does not support input files (not hard to implement, though) 194 raise errors.ProgrammerError("Parameters 'output' and 'input_fd' can" 195 " not be used at the same time") 196 197 if isinstance(cmd, basestring): 198 strcmd = cmd 199 shell = True 200 else: 201 cmd = [str(val) for val in cmd] 202 strcmd = utils_text.ShellQuoteArgs(cmd) 203 shell = False 204 205 if output: 206 logging.info("RunCmd %s, output file '%s'", strcmd, output) 207 else: 208 logging.info("RunCmd %s", strcmd) 209 210 cmd_env = _BuildCmdEnvironment(env, reset_env) 211 212 try: 213 if output is None: 214 out, err, status, timeout_action = _RunCmdPipe(cmd, cmd_env, shell, cwd, 215 interactive, timeout, 216 noclose_fds, input_fd, 217 postfork_fn=postfork_fn) 218 else: 219 if postfork_fn: 220 raise errors.ProgrammerError("postfork_fn is not supported if output" 221 " should be captured") 222 assert input_fd is None 223 timeout_action = _TIMEOUT_NONE 224 status = _RunCmdFile(cmd, cmd_env, shell, output, cwd, noclose_fds) 225 out = err = "" 226 except OSError, err: 227 if err.errno == errno.ENOENT: 228 raise errors.OpExecError("Can't execute '%s': not found (%s)" % 229 (strcmd, err)) 230 else: 231 raise 232 233 if status >= 0: 234 exitcode = status 235 signal_ = None 236 else: 237 exitcode = None 238 signal_ = -status 239 240 return RunResult(exitcode, signal_, out, err, strcmd, timeout_action, timeout)
241 242
243 -def SetupDaemonEnv(cwd="/", umask=077):
244 """Setup a daemon's environment. 245 246 This should be called between the first and second fork, due to 247 setsid usage. 248 249 @param cwd: the directory to which to chdir 250 @param umask: the umask to setup 251 252 """ 253 os.chdir(cwd) 254 os.umask(umask) 255 os.setsid()
256 257
258 -def SetupDaemonFDs(output_file, output_fd):
259 """Setups up a daemon's file descriptors. 260 261 @param output_file: if not None, the file to which to redirect 262 stdout/stderr 263 @param output_fd: if not None, the file descriptor for stdout/stderr 264 265 """ 266 # check that at most one is defined 267 assert [output_file, output_fd].count(None) >= 1 268 269 # Open /dev/null (read-only, only for stdin) 270 devnull_fd = os.open(os.devnull, os.O_RDONLY) 271 272 output_close = True 273 274 if output_fd is not None: 275 output_close = False 276 elif output_file is not None: 277 # Open output file 278 try: 279 output_fd = os.open(output_file, 280 os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0600) 281 except EnvironmentError, err: 282 raise Exception("Opening output file failed: %s" % err) 283 else: 284 output_fd = os.open(os.devnull, os.O_WRONLY) 285 286 # Redirect standard I/O 287 os.dup2(devnull_fd, 0) 288 os.dup2(output_fd, 1) 289 os.dup2(output_fd, 2) 290 291 if devnull_fd > 2: 292 utils_wrapper.CloseFdNoError(devnull_fd) 293 294 if output_close and output_fd > 2: 295 utils_wrapper.CloseFdNoError(output_fd)
296 297
298 -def StartDaemon(cmd, env=None, cwd="/", output=None, output_fd=None, 299 pidfile=None):
300 """Start a daemon process after forking twice. 301 302 @type cmd: string or list 303 @param cmd: Command to run 304 @type env: dict 305 @param env: Additional environment variables 306 @type cwd: string 307 @param cwd: Working directory for the program 308 @type output: string 309 @param output: Path to file in which to save the output 310 @type output_fd: int 311 @param output_fd: File descriptor for output 312 @type pidfile: string 313 @param pidfile: Process ID file 314 @rtype: int 315 @return: Daemon process ID 316 @raise errors.ProgrammerError: if we call this when forks are disabled 317 318 """ 319 if _no_fork: 320 raise errors.ProgrammerError("utils.StartDaemon() called with fork()" 321 " disabled") 322 323 if output and not (bool(output) ^ (output_fd is not None)): 324 raise errors.ProgrammerError("Only one of 'output' and 'output_fd' can be" 325 " specified") 326 327 if isinstance(cmd, basestring): 328 cmd = ["/bin/sh", "-c", cmd] 329 330 strcmd = utils_text.ShellQuoteArgs(cmd) 331 332 if output: 333 logging.debug("StartDaemon %s, output file '%s'", strcmd, output) 334 else: 335 logging.debug("StartDaemon %s", strcmd) 336 337 cmd_env = _BuildCmdEnvironment(env, False) 338 339 # Create pipe for sending PID back 340 (pidpipe_read, pidpipe_write) = os.pipe() 341 try: 342 try: 343 # Create pipe for sending error messages 344 (errpipe_read, errpipe_write) = os.pipe() 345 try: 346 try: 347 # First fork 348 pid = os.fork() 349 if pid == 0: 350 try: 351 # Child process, won't return 352 _StartDaemonChild(errpipe_read, errpipe_write, 353 pidpipe_read, pidpipe_write, 354 cmd, cmd_env, cwd, 355 output, output_fd, pidfile) 356 finally: 357 # Well, maybe child process failed 358 os._exit(1) # pylint: disable=W0212 359 finally: 360 utils_wrapper.CloseFdNoError(errpipe_write) 361 362 # Wait for daemon to be started (or an error message to 363 # arrive) and read up to 100 KB as an error message 364 errormsg = utils_wrapper.RetryOnSignal(os.read, errpipe_read, 365 100 * 1024) 366 finally: 367 utils_wrapper.CloseFdNoError(errpipe_read) 368 finally: 369 utils_wrapper.CloseFdNoError(pidpipe_write) 370 371 # Read up to 128 bytes for PID 372 pidtext = utils_wrapper.RetryOnSignal(os.read, pidpipe_read, 128) 373 finally: 374 utils_wrapper.CloseFdNoError(pidpipe_read) 375 376 # Try to avoid zombies by waiting for child process 377 try: 378 os.waitpid(pid, 0) 379 except OSError: 380 pass 381 382 if errormsg: 383 raise errors.OpExecError("Error when starting daemon process: %r" % 384 errormsg) 385 386 try: 387 return int(pidtext) 388 except (ValueError, TypeError), err: 389 raise errors.OpExecError("Error while trying to parse PID %r: %s" % 390 (pidtext, err))
391 392
393 -def _StartDaemonChild(errpipe_read, errpipe_write, 394 pidpipe_read, pidpipe_write, 395 args, env, cwd, 396 output, fd_output, pidfile):
397 """Child process for starting daemon. 398 399 """ 400 try: 401 # Close parent's side 402 utils_wrapper.CloseFdNoError(errpipe_read) 403 utils_wrapper.CloseFdNoError(pidpipe_read) 404 405 # First child process 406 SetupDaemonEnv() 407 408 # And fork for the second time 409 pid = os.fork() 410 if pid != 0: 411 # Exit first child process 412 os._exit(0) # pylint: disable=W0212 413 414 # Make sure pipe is closed on execv* (and thereby notifies 415 # original process) 416 utils_wrapper.SetCloseOnExecFlag(errpipe_write, True) 417 418 # List of file descriptors to be left open 419 noclose_fds = [errpipe_write] 420 421 # Open PID file 422 if pidfile: 423 fd_pidfile = utils_io.WritePidFile(pidfile) 424 425 # Keeping the file open to hold the lock 426 noclose_fds.append(fd_pidfile) 427 428 utils_wrapper.SetCloseOnExecFlag(fd_pidfile, False) 429 else: 430 fd_pidfile = None 431 432 SetupDaemonFDs(output, fd_output) 433 434 # Send daemon PID to parent 435 utils_wrapper.RetryOnSignal(os.write, pidpipe_write, str(os.getpid())) 436 437 # Close all file descriptors except stdio and error message pipe 438 CloseFDs(noclose_fds=noclose_fds) 439 440 # Change working directory 441 os.chdir(cwd) 442 443 if env is None: 444 os.execvp(args[0], args) 445 else: 446 os.execvpe(args[0], args, env) 447 except: # pylint: disable=W0702 448 try: 449 # Report errors to original process 450 WriteErrorToFD(errpipe_write, str(sys.exc_info()[1])) 451 except: # pylint: disable=W0702 452 # Ignore errors in error handling 453 pass 454 455 os._exit(1) # pylint: disable=W0212
456 457
458 -def WriteErrorToFD(fd, err):
459 """Possibly write an error message to a fd. 460 461 @type fd: None or int (file descriptor) 462 @param fd: if not None, the error will be written to this fd 463 @param err: string, the error message 464 465 """ 466 if fd is None: 467 return 468 469 if not err: 470 err = "<unknown error>" 471 472 utils_wrapper.RetryOnSignal(os.write, fd, err)
473 474
475 -def _CheckIfAlive(child):
476 """Raises L{utils_retry.RetryAgain} if child is still alive. 477 478 @raises utils_retry.RetryAgain: If child is still alive 479 480 """ 481 if child.poll() is None: 482 raise utils_retry.RetryAgain()
483 484
485 -def _WaitForProcess(child, timeout):
486 """Waits for the child to terminate or until we reach timeout. 487 488 """ 489 try: 490 utils_retry.Retry(_CheckIfAlive, (1.0, 1.2, 5.0), max(0, timeout), 491 args=[child]) 492 except utils_retry.RetryTimeout: 493 pass
494 495
496 -def _RunCmdPipe(cmd, env, via_shell, cwd, interactive, timeout, noclose_fds, 497 input_fd, postfork_fn=None, 498 _linger_timeout=constants.CHILD_LINGER_TIMEOUT):
499 """Run a command and return its output. 500 501 @type cmd: string or list 502 @param cmd: Command to run 503 @type env: dict 504 @param env: The environment to use 505 @type via_shell: bool 506 @param via_shell: if we should run via the shell 507 @type cwd: string 508 @param cwd: the working directory for the program 509 @type interactive: boolean 510 @param interactive: Run command interactive (without piping) 511 @type timeout: int 512 @param timeout: Timeout after the programm gets terminated 513 @type noclose_fds: list 514 @param noclose_fds: list of additional (fd >=3) file descriptors to leave 515 open for the child process 516 @type input_fd: C{file}-like object or numeric file descriptor 517 @param input_fd: File descriptor for process' standard input 518 @type postfork_fn: Callable receiving PID as parameter 519 @param postfork_fn: Function run after fork but before timeout 520 @rtype: tuple 521 @return: (out, err, status) 522 523 """ 524 poller = select.poll() 525 526 if interactive: 527 stderr = None 528 stdout = None 529 else: 530 stderr = subprocess.PIPE 531 stdout = subprocess.PIPE 532 533 if input_fd: 534 stdin = input_fd 535 elif interactive: 536 stdin = None 537 else: 538 stdin = subprocess.PIPE 539 540 if noclose_fds: 541 preexec_fn = lambda: CloseFDs(noclose_fds) 542 close_fds = False 543 else: 544 preexec_fn = None 545 close_fds = True 546 547 child = subprocess.Popen(cmd, shell=via_shell, 548 stderr=stderr, 549 stdout=stdout, 550 stdin=stdin, 551 close_fds=close_fds, env=env, 552 cwd=cwd, 553 preexec_fn=preexec_fn) 554 555 if postfork_fn: 556 postfork_fn(child.pid) 557 558 out = StringIO() 559 err = StringIO() 560 561 linger_timeout = None 562 563 if timeout is None: 564 poll_timeout = None 565 else: 566 poll_timeout = utils_algo.RunningTimeout(timeout, True).Remaining 567 568 msg_timeout = ("Command %s (%d) run into execution timeout, terminating" % 569 (cmd, child.pid)) 570 msg_linger = ("Command %s (%d) run into linger timeout, killing" % 571 (cmd, child.pid)) 572 573 timeout_action = _TIMEOUT_NONE 574 575 # subprocess: "If the stdin argument is PIPE, this attribute is a file object 576 # that provides input to the child process. Otherwise, it is None." 577 assert (stdin == subprocess.PIPE) ^ (child.stdin is None), \ 578 "subprocess' stdin did not behave as documented" 579 580 if not interactive: 581 if child.stdin is not None: 582 child.stdin.close() 583 poller.register(child.stdout, select.POLLIN) 584 poller.register(child.stderr, select.POLLIN) 585 fdmap = { 586 child.stdout.fileno(): (out, child.stdout), 587 child.stderr.fileno(): (err, child.stderr), 588 } 589 for fd in fdmap: 590 utils_wrapper.SetNonblockFlag(fd, True) 591 592 while fdmap: 593 if poll_timeout: 594 pt = poll_timeout() * 1000 595 if pt < 0: 596 if linger_timeout is None: 597 logging.warning(msg_timeout) 598 if child.poll() is None: 599 timeout_action = _TIMEOUT_TERM 600 utils_wrapper.IgnoreProcessNotFound(os.kill, child.pid, 601 signal.SIGTERM) 602 linger_timeout = \ 603 utils_algo.RunningTimeout(_linger_timeout, True).Remaining 604 pt = linger_timeout() * 1000 605 if pt < 0: 606 break 607 else: 608 pt = None 609 610 pollresult = utils_wrapper.RetryOnSignal(poller.poll, pt) 611 612 for fd, event in pollresult: 613 if event & select.POLLIN or event & select.POLLPRI: 614 data = fdmap[fd][1].read() 615 # no data from read signifies EOF (the same as POLLHUP) 616 if not data: 617 poller.unregister(fd) 618 del fdmap[fd] 619 continue 620 fdmap[fd][0].write(data) 621 if (event & select.POLLNVAL or event & select.POLLHUP or 622 event & select.POLLERR): 623 poller.unregister(fd) 624 del fdmap[fd] 625 626 if timeout is not None: 627 assert callable(poll_timeout) 628 629 # We have no I/O left but it might still run 630 if child.poll() is None: 631 _WaitForProcess(child, poll_timeout()) 632 633 # Terminate if still alive after timeout 634 if child.poll() is None: 635 if linger_timeout is None: 636 logging.warning(msg_timeout) 637 timeout_action = _TIMEOUT_TERM 638 utils_wrapper.IgnoreProcessNotFound(os.kill, child.pid, signal.SIGTERM) 639 lt = _linger_timeout 640 else: 641 lt = linger_timeout() 642 _WaitForProcess(child, lt) 643 644 # Okay, still alive after timeout and linger timeout? Kill it! 645 if child.poll() is None: 646 timeout_action = _TIMEOUT_KILL 647 logging.warning(msg_linger) 648 utils_wrapper.IgnoreProcessNotFound(os.kill, child.pid, signal.SIGKILL) 649 650 out = out.getvalue() 651 err = err.getvalue() 652 653 status = child.wait() 654 return out, err, status, timeout_action
655 656
657 -def _RunCmdFile(cmd, env, via_shell, output, cwd, noclose_fds):
658 """Run a command and save its output to a file. 659 660 @type cmd: string or list 661 @param cmd: Command to run 662 @type env: dict 663 @param env: The environment to use 664 @type via_shell: bool 665 @param via_shell: if we should run via the shell 666 @type output: str 667 @param output: the filename in which to save the output 668 @type cwd: string 669 @param cwd: the working directory for the program 670 @type noclose_fds: list 671 @param noclose_fds: list of additional (fd >=3) file descriptors to leave 672 open for the child process 673 @rtype: int 674 @return: the exit status 675 676 """ 677 fh = open(output, "a") 678 679 if noclose_fds: 680 preexec_fn = lambda: CloseFDs(noclose_fds + [fh.fileno()]) 681 close_fds = False 682 else: 683 preexec_fn = None 684 close_fds = True 685 686 try: 687 child = subprocess.Popen(cmd, shell=via_shell, 688 stderr=subprocess.STDOUT, 689 stdout=fh, 690 stdin=subprocess.PIPE, 691 close_fds=close_fds, env=env, 692 cwd=cwd, 693 preexec_fn=preexec_fn) 694 695 child.stdin.close() 696 status = child.wait() 697 finally: 698 fh.close() 699 return status
700 701
702 -def RunParts(dir_name, env=None, reset_env=False):
703 """Run Scripts or programs in a directory 704 705 @type dir_name: string 706 @param dir_name: absolute path to a directory 707 @type env: dict 708 @param env: The environment to use 709 @type reset_env: boolean 710 @param reset_env: whether to reset or keep the default os environment 711 @rtype: list of tuples 712 @return: list of (name, (one of RUNDIR_STATUS), RunResult) 713 714 """ 715 rr = [] 716 717 try: 718 dir_contents = utils_io.ListVisibleFiles(dir_name) 719 except OSError, err: 720 logging.warning("RunParts: skipping %s (cannot list: %s)", dir_name, err) 721 return rr 722 723 for relname in sorted(dir_contents): 724 fname = utils_io.PathJoin(dir_name, relname) 725 if not (constants.EXT_PLUGIN_MASK.match(relname) is not None and 726 utils_wrapper.IsExecutable(fname)): 727 rr.append((relname, constants.RUNPARTS_SKIP, None)) 728 else: 729 try: 730 result = RunCmd([fname], env=env, reset_env=reset_env) 731 except Exception, err: # pylint: disable=W0703 732 rr.append((relname, constants.RUNPARTS_ERR, str(err))) 733 else: 734 rr.append((relname, constants.RUNPARTS_RUN, result)) 735 736 return rr
737 738
739 -def _GetProcStatusPath(pid):
740 """Returns the path for a PID's proc status file. 741 742 @type pid: int 743 @param pid: Process ID 744 @rtype: string 745 746 """ 747 return "/proc/%d/status" % pid
748 749
750 -def IsProcessAlive(pid):
751 """Check if a given pid exists on the system. 752 753 @note: zombie status is not handled, so zombie processes 754 will be returned as alive 755 @type pid: int 756 @param pid: the process ID to check 757 @rtype: boolean 758 @return: True if the process exists 759 760 """ 761 def _TryStat(name): 762 try: 763 os.stat(name) 764 return True 765 except EnvironmentError, err: 766 if err.errno in (errno.ENOENT, errno.ENOTDIR): 767 return False 768 elif err.errno == errno.EINVAL: 769 raise utils_retry.RetryAgain(err) 770 raise
771 772 assert isinstance(pid, int), "pid must be an integer" 773 if pid <= 0: 774 return False 775 776 # /proc in a multiprocessor environment can have strange behaviors. 777 # Retry the os.stat a few times until we get a good result. 778 try: 779 return utils_retry.Retry(_TryStat, (0.01, 1.5, 0.1), 0.5, 780 args=[_GetProcStatusPath(pid)]) 781 except utils_retry.RetryTimeout, err: 782 err.RaiseInner() 783 784
785 -def _ParseSigsetT(sigset):
786 """Parse a rendered sigset_t value. 787 788 This is the opposite of the Linux kernel's fs/proc/array.c:render_sigset_t 789 function. 790 791 @type sigset: string 792 @param sigset: Rendered signal set from /proc/$pid/status 793 @rtype: set 794 @return: Set of all enabled signal numbers 795 796 """ 797 result = set() 798 799 signum = 0 800 for ch in reversed(sigset): 801 chv = int(ch, 16) 802 803 # The following could be done in a loop, but it's easier to read and 804 # understand in the unrolled form 805 if chv & 1: 806 result.add(signum + 1) 807 if chv & 2: 808 result.add(signum + 2) 809 if chv & 4: 810 result.add(signum + 3) 811 if chv & 8: 812 result.add(signum + 4) 813 814 signum += 4 815 816 return result
817 818
819 -def _GetProcStatusField(pstatus, field):
820 """Retrieves a field from the contents of a proc status file. 821 822 @type pstatus: string 823 @param pstatus: Contents of /proc/$pid/status 824 @type field: string 825 @param field: Name of field whose value should be returned 826 @rtype: string 827 828 """ 829 for line in pstatus.splitlines(): 830 parts = line.split(":", 1) 831 832 if len(parts) < 2 or parts[0] != field: 833 continue 834 835 return parts[1].strip() 836 837 return None
838 839
840 -def IsProcessHandlingSignal(pid, signum, status_path=None):
841 """Checks whether a process is handling a signal. 842 843 @type pid: int 844 @param pid: Process ID 845 @type signum: int 846 @param signum: Signal number 847 @rtype: bool 848 849 """ 850 if status_path is None: 851 status_path = _GetProcStatusPath(pid) 852 853 try: 854 proc_status = utils_io.ReadFile(status_path) 855 except EnvironmentError, err: 856 # In at least one case, reading /proc/$pid/status failed with ESRCH. 857 if err.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL, errno.ESRCH): 858 return False 859 raise 860 861 sigcgt = _GetProcStatusField(proc_status, "SigCgt") 862 if sigcgt is None: 863 raise RuntimeError("%s is missing 'SigCgt' field" % status_path) 864 865 # Now check whether signal is handled 866 return signum in _ParseSigsetT(sigcgt)
867 868
869 -def Daemonize(logfile):
870 """Daemonize the current process. 871 872 This detaches the current process from the controlling terminal and 873 runs it in the background as a daemon. 874 875 @type logfile: str 876 @param logfile: the logfile to which we should redirect stdout/stderr 877 @rtype: tuple; (int, callable) 878 @return: File descriptor of pipe(2) which must be closed to notify parent 879 process and a callable to reopen log files 880 881 """ 882 # pylint: disable=W0212 883 # yes, we really want os._exit 884 885 # TODO: do another attempt to merge Daemonize and StartDaemon, or at 886 # least abstract the pipe functionality between them 887 888 # Create pipe for sending error messages 889 (rpipe, wpipe) = os.pipe() 890 891 # this might fail 892 pid = os.fork() 893 if (pid == 0): # The first child. 894 SetupDaemonEnv() 895 896 # this might fail 897 pid = os.fork() # Fork a second child. 898 if (pid == 0): # The second child. 899 utils_wrapper.CloseFdNoError(rpipe) 900 else: 901 # exit() or _exit()? See below. 902 os._exit(0) # Exit parent (the first child) of the second child. 903 else: 904 utils_wrapper.CloseFdNoError(wpipe) 905 # Wait for daemon to be started (or an error message to 906 # arrive) and read up to 100 KB as an error message 907 errormsg = utils_wrapper.RetryOnSignal(os.read, rpipe, 100 * 1024) 908 if errormsg: 909 sys.stderr.write("Error when starting daemon process: %r\n" % errormsg) 910 rcode = 1 911 else: 912 rcode = 0 913 os._exit(rcode) # Exit parent of the first child. 914 915 reopen_fn = compat.partial(SetupDaemonFDs, logfile, None) 916 917 # Open logs for the first time 918 reopen_fn() 919 920 return (wpipe, reopen_fn)
921 922
923 -def KillProcess(pid, signal_=signal.SIGTERM, timeout=30, 924 waitpid=False):
925 """Kill a process given by its pid. 926 927 @type pid: int 928 @param pid: The PID to terminate. 929 @type signal_: int 930 @param signal_: The signal to send, by default SIGTERM 931 @type timeout: int 932 @param timeout: The timeout after which, if the process is still alive, 933 a SIGKILL will be sent. If not positive, no such checking 934 will be done 935 @type waitpid: boolean 936 @param waitpid: If true, we should waitpid on this process after 937 sending signals, since it's our own child and otherwise it 938 would remain as zombie 939 940 """ 941 def _helper(pid, signal_, wait): 942 """Simple helper to encapsulate the kill/waitpid sequence""" 943 if utils_wrapper.IgnoreProcessNotFound(os.kill, pid, signal_) and wait: 944 try: 945 os.waitpid(pid, os.WNOHANG) 946 except OSError: 947 pass
948 949 if pid <= 0: 950 # kill with pid=0 == suicide 951 raise errors.ProgrammerError("Invalid pid given '%s'" % pid) 952 953 if not IsProcessAlive(pid): 954 return 955 956 _helper(pid, signal_, waitpid) 957 958 if timeout <= 0: 959 return 960 961 def _CheckProcess(): 962 if not IsProcessAlive(pid): 963 return 964 965 try: 966 (result_pid, _) = os.waitpid(pid, os.WNOHANG) 967 except OSError: 968 raise utils_retry.RetryAgain() 969 970 if result_pid > 0: 971 return 972 973 raise utils_retry.RetryAgain() 974 975 try: 976 # Wait up to $timeout seconds 977 utils_retry.Retry(_CheckProcess, (0.01, 1.5, 0.1), timeout) 978 except utils_retry.RetryTimeout: 979 pass 980 981 if IsProcessAlive(pid): 982 # Kill process if it's still alive 983 _helper(pid, signal.SIGKILL, waitpid) 984 985
986 -def RunInSeparateProcess(fn, *args):
987 """Runs a function in a separate process. 988 989 Note: Only boolean return values are supported. 990 991 @type fn: callable 992 @param fn: Function to be called 993 @rtype: bool 994 @return: Function's result 995 996 """ 997 pid = os.fork() 998 if pid == 0: 999 # Child process 1000 try: 1001 # In case the function uses temporary files 1002 utils_wrapper.ResetTempfileModule() 1003 1004 # Call function 1005 result = int(bool(fn(*args))) 1006 assert result in (0, 1) 1007 except: # pylint: disable=W0702 1008 logging.exception("Error while calling function in separate process") 1009 # 0 and 1 are reserved for the return value 1010 result = 33 1011 1012 os._exit(result) # pylint: disable=W0212 1013 1014 # Parent process 1015 1016 # Avoid zombies and check exit code 1017 (_, status) = os.waitpid(pid, 0) 1018 1019 if os.WIFSIGNALED(status): 1020 exitcode = None 1021 signum = os.WTERMSIG(status) 1022 else: 1023 exitcode = os.WEXITSTATUS(status) 1024 signum = None 1025 1026 if not (exitcode in (0, 1) and signum is None): 1027 raise errors.GenericError("Child program failed (code=%s, signal=%s)" % 1028 (exitcode, signum)) 1029 1030 return bool(exitcode)
1031 1032
1033 -def CloseFDs(noclose_fds=None):
1034 """Close file descriptors. 1035 1036 This closes all file descriptors above 2 (i.e. except 1037 stdin/out/err). 1038 1039 @type noclose_fds: list or None 1040 @param noclose_fds: if given, it denotes a list of file descriptor 1041 that should not be closed 1042 1043 """ 1044 # Default maximum for the number of available file descriptors. 1045 if 'SC_OPEN_MAX' in os.sysconf_names: 1046 try: 1047 MAXFD = os.sysconf('SC_OPEN_MAX') 1048 if MAXFD < 0: 1049 MAXFD = 1024 1050 except OSError: 1051 MAXFD = 1024 1052 else: 1053 MAXFD = 1024 1054 1055 maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1] 1056 if (maxfd == resource.RLIM_INFINITY): 1057 maxfd = MAXFD 1058 1059 # Iterate through and close all file descriptors (except the standard ones) 1060 for fd in range(3, maxfd): 1061 if noclose_fds and fd in noclose_fds: 1062 continue 1063 utils_wrapper.CloseFdNoError(fd)
1064