Statistics
| Branch: | Tag: | Revision:

root / lib / utils / process.py @ adc523ab

History | View | Annotate | Download (27.8 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2010, 2011 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

    
40
from ganeti.utils import retry as utils_retry
41
from ganeti.utils import wrapper as utils_wrapper
42
from ganeti.utils import text as utils_text
43
from ganeti.utils import io as utils_io
44
from ganeti.utils import algo as utils_algo
45

    
46

    
47
#: when set to True, L{RunCmd} is disabled
48
_no_fork = False
49

    
50
(_TIMEOUT_NONE,
51
 _TIMEOUT_TERM,
52
 _TIMEOUT_KILL) = range(3)
53

    
54

    
55
def DisableFork():
56
  """Disables the use of fork(2).
57

58
  """
59
  global _no_fork # pylint: disable-msg=W0603
60

    
61
  _no_fork = True
62

    
63

    
64
class RunResult(object):
65
  """Holds the result of running external programs.
66

67
  @type exit_code: int
68
  @ivar exit_code: the exit code of the program, or None (if the program
69
      didn't exit())
70
  @type signal: int or None
71
  @ivar signal: the signal that caused the program to finish, or None
72
      (if the program wasn't terminated by a signal)
73
  @type stdout: str
74
  @ivar stdout: the standard output of the program
75
  @type stderr: str
76
  @ivar stderr: the standard error of the program
77
  @type failed: boolean
78
  @ivar failed: True in case the program was
79
      terminated by a signal or exited with a non-zero exit code
80
  @ivar fail_reason: a string detailing the termination reason
81

82
  """
83
  __slots__ = ["exit_code", "signal", "stdout", "stderr",
84
               "failed", "fail_reason", "cmd"]
85

    
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

    
114
    if self.failed:
115
      logging.debug("Command '%s' failed (%s); output: %s",
116
                    self.cmd, self.fail_reason, self.output)
117

    
118
  def _GetOutput(self):
119
    """Returns the combined stdout and stderr for easier usage.
120

121
    """
122
    return self.stdout + self.stderr
123

    
124
  output = property(_GetOutput, None, None, "Return full output")
125

    
126

    
127
def _BuildCmdEnvironment(env, reset):
128
  """Builds the environment for an external program.
129

130
  """
131
  if reset:
132
    cmd_env = {}
133
  else:
134
    cmd_env = os.environ.copy()
135
    cmd_env["LC_ALL"] = "C"
136

    
137
  if env is not None:
138
    cmd_env.update(env)
139

    
140
  return cmd_env
141

    
142

    
143
def RunCmd(cmd, env=None, output=None, cwd="/", reset_env=False,
144
           interactive=False, timeout=None, noclose_fds=None):
145
  """Execute a (shell) command.
146

147
  The command should not read from its standard input, as it will be
148
  closed.
149

150
  @type cmd: string or list
151
  @param cmd: Command to run
152
  @type env: dict
153
  @param env: Additional environment variables
154
  @type output: str
155
  @param output: if desired, the output of the command can be
156
      saved in a file instead of the RunResult instance; this
157
      parameter denotes the file name (if not None)
158
  @type cwd: string
159
  @param cwd: if specified, will be used as the working
160
      directory for the command; the default will be /
161
  @type reset_env: boolean
162
  @param reset_env: whether to reset or keep the default os environment
163
  @type interactive: boolean
164
  @param interactive: weather we pipe stdin, stdout and stderr
165
                      (default behaviour) or run the command interactive
166
  @type timeout: int
167
  @param timeout: If not None, timeout in seconds until child process gets
168
                  killed
169
  @type noclose_fds: list
170
  @param noclose_fds: list of additional (fd >=3) file descriptors to leave
171
                      open for the child process
172
  @rtype: L{RunResult}
173
  @return: RunResult instance
174
  @raise errors.ProgrammerError: if we call this when forks are disabled
175

176
  """
177
  if _no_fork:
178
    raise errors.ProgrammerError("utils.RunCmd() called with fork() disabled")
179

    
180
  if output and interactive:
181
    raise errors.ProgrammerError("Parameters 'output' and 'interactive' can"
182
                                 " not be provided at the same time")
183

    
184
  if isinstance(cmd, basestring):
185
    strcmd = cmd
186
    shell = True
187
  else:
188
    cmd = [str(val) for val in cmd]
189
    strcmd = utils_text.ShellQuoteArgs(cmd)
190
    shell = False
191

    
192
  if output:
193
    logging.debug("RunCmd %s, output file '%s'", strcmd, output)
194
  else:
195
    logging.debug("RunCmd %s", strcmd)
196

    
197
  cmd_env = _BuildCmdEnvironment(env, reset_env)
198

    
199
  try:
200
    if output is None:
201
      out, err, status, timeout_action = _RunCmdPipe(cmd, cmd_env, shell, cwd,
202
                                                     interactive, timeout,
203
                                                     noclose_fds)
204
    else:
205
      timeout_action = _TIMEOUT_NONE
206
      status = _RunCmdFile(cmd, cmd_env, shell, output, cwd, noclose_fds)
207
      out = err = ""
208
  except OSError, err:
209
    if err.errno == errno.ENOENT:
210
      raise errors.OpExecError("Can't execute '%s': not found (%s)" %
211
                               (strcmd, err))
212
    else:
213
      raise
214

    
215
  if status >= 0:
216
    exitcode = status
217
    signal_ = None
218
  else:
219
    exitcode = None
220
    signal_ = -status
221

    
222
  return RunResult(exitcode, signal_, out, err, strcmd, timeout_action, timeout)
223

    
224

    
225
def SetupDaemonEnv(cwd="/", umask=077):
226
  """Setup a daemon's environment.
227

228
  This should be called between the first and second fork, due to
229
  setsid usage.
230

231
  @param cwd: the directory to which to chdir
232
  @param umask: the umask to setup
233

234
  """
235
  os.chdir(cwd)
236
  os.umask(umask)
237
  os.setsid()
238

    
239

    
240
def SetupDaemonFDs(output_file, output_fd):
241
  """Setups up a daemon's file descriptors.
242

243
  @param output_file: if not None, the file to which to redirect
244
      stdout/stderr
245
  @param output_fd: if not None, the file descriptor for stdout/stderr
246

247
  """
248
  # check that at most one is defined
249
  assert [output_file, output_fd].count(None) >= 1
250

    
251
  # Open /dev/null (read-only, only for stdin)
252
  devnull_fd = os.open(os.devnull, os.O_RDONLY)
253

    
254
  if output_fd is not None:
255
    pass
256
  elif output_file is not None:
257
    # Open output file
258
    try:
259
      output_fd = os.open(output_file,
260
                          os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0600)
261
    except EnvironmentError, err:
262
      raise Exception("Opening output file failed: %s" % err)
263
  else:
264
    output_fd = os.open(os.devnull, os.O_WRONLY)
265

    
266
  # Redirect standard I/O
267
  os.dup2(devnull_fd, 0)
268
  os.dup2(output_fd, 1)
269
  os.dup2(output_fd, 2)
270

    
271

    
272
def StartDaemon(cmd, env=None, cwd="/", output=None, output_fd=None,
273
                pidfile=None):
274
  """Start a daemon process after forking twice.
275

276
  @type cmd: string or list
277
  @param cmd: Command to run
278
  @type env: dict
279
  @param env: Additional environment variables
280
  @type cwd: string
281
  @param cwd: Working directory for the program
282
  @type output: string
283
  @param output: Path to file in which to save the output
284
  @type output_fd: int
285
  @param output_fd: File descriptor for output
286
  @type pidfile: string
287
  @param pidfile: Process ID file
288
  @rtype: int
289
  @return: Daemon process ID
290
  @raise errors.ProgrammerError: if we call this when forks are disabled
291

292
  """
293
  if _no_fork:
294
    raise errors.ProgrammerError("utils.StartDaemon() called with fork()"
295
                                 " disabled")
296

    
297
  if output and not (bool(output) ^ (output_fd is not None)):
298
    raise errors.ProgrammerError("Only one of 'output' and 'output_fd' can be"
299
                                 " specified")
300

    
301
  if isinstance(cmd, basestring):
302
    cmd = ["/bin/sh", "-c", cmd]
303

    
304
  strcmd = utils_text.ShellQuoteArgs(cmd)
305

    
306
  if output:
307
    logging.debug("StartDaemon %s, output file '%s'", strcmd, output)
308
  else:
309
    logging.debug("StartDaemon %s", strcmd)
310

    
311
  cmd_env = _BuildCmdEnvironment(env, False)
312

    
313
  # Create pipe for sending PID back
314
  (pidpipe_read, pidpipe_write) = os.pipe()
315
  try:
316
    try:
317
      # Create pipe for sending error messages
318
      (errpipe_read, errpipe_write) = os.pipe()
319
      try:
320
        try:
321
          # First fork
322
          pid = os.fork()
323
          if pid == 0:
324
            try:
325
              # Child process, won't return
326
              _StartDaemonChild(errpipe_read, errpipe_write,
327
                                pidpipe_read, pidpipe_write,
328
                                cmd, cmd_env, cwd,
329
                                output, output_fd, pidfile)
330
            finally:
331
              # Well, maybe child process failed
332
              os._exit(1) # pylint: disable-msg=W0212
333
        finally:
334
          utils_wrapper.CloseFdNoError(errpipe_write)
335

    
336
        # Wait for daemon to be started (or an error message to
337
        # arrive) and read up to 100 KB as an error message
338
        errormsg = utils_wrapper.RetryOnSignal(os.read, errpipe_read,
339
                                               100 * 1024)
340
      finally:
341
        utils_wrapper.CloseFdNoError(errpipe_read)
342
    finally:
343
      utils_wrapper.CloseFdNoError(pidpipe_write)
344

    
345
    # Read up to 128 bytes for PID
346
    pidtext = utils_wrapper.RetryOnSignal(os.read, pidpipe_read, 128)
347
  finally:
348
    utils_wrapper.CloseFdNoError(pidpipe_read)
349

    
350
  # Try to avoid zombies by waiting for child process
351
  try:
352
    os.waitpid(pid, 0)
353
  except OSError:
354
    pass
355

    
356
  if errormsg:
357
    raise errors.OpExecError("Error when starting daemon process: %r" %
358
                             errormsg)
359

    
360
  try:
361
    return int(pidtext)
362
  except (ValueError, TypeError), err:
363
    raise errors.OpExecError("Error while trying to parse PID %r: %s" %
364
                             (pidtext, err))
365

    
366

    
367
def _StartDaemonChild(errpipe_read, errpipe_write,
368
                      pidpipe_read, pidpipe_write,
369
                      args, env, cwd,
370
                      output, fd_output, pidfile):
371
  """Child process for starting daemon.
372

373
  """
374
  try:
375
    # Close parent's side
376
    utils_wrapper.CloseFdNoError(errpipe_read)
377
    utils_wrapper.CloseFdNoError(pidpipe_read)
378

    
379
    # First child process
380
    SetupDaemonEnv()
381

    
382
    # And fork for the second time
383
    pid = os.fork()
384
    if pid != 0:
385
      # Exit first child process
386
      os._exit(0) # pylint: disable-msg=W0212
387

    
388
    # Make sure pipe is closed on execv* (and thereby notifies
389
    # original process)
390
    utils_wrapper.SetCloseOnExecFlag(errpipe_write, True)
391

    
392
    # List of file descriptors to be left open
393
    noclose_fds = [errpipe_write]
394

    
395
    # Open PID file
396
    if pidfile:
397
      fd_pidfile = utils_io.WritePidFile(pidfile)
398

    
399
      # Keeping the file open to hold the lock
400
      noclose_fds.append(fd_pidfile)
401

    
402
      utils_wrapper.SetCloseOnExecFlag(fd_pidfile, False)
403
    else:
404
      fd_pidfile = None
405

    
406
    SetupDaemonFDs(output, fd_output)
407

    
408
    # Send daemon PID to parent
409
    utils_wrapper.RetryOnSignal(os.write, pidpipe_write, str(os.getpid()))
410

    
411
    # Close all file descriptors except stdio and error message pipe
412
    CloseFDs(noclose_fds=noclose_fds)
413

    
414
    # Change working directory
415
    os.chdir(cwd)
416

    
417
    if env is None:
418
      os.execvp(args[0], args)
419
    else:
420
      os.execvpe(args[0], args, env)
421
  except: # pylint: disable-msg=W0702
422
    try:
423
      # Report errors to original process
424
      WriteErrorToFD(errpipe_write, str(sys.exc_info()[1]))
425
    except: # pylint: disable-msg=W0702
426
      # Ignore errors in error handling
427
      pass
428

    
429
  os._exit(1) # pylint: disable-msg=W0212
430

    
431

    
432
def WriteErrorToFD(fd, err):
433
  """Possibly write an error message to a fd.
434

435
  @type fd: None or int (file descriptor)
436
  @param fd: if not None, the error will be written to this fd
437
  @param err: string, the error message
438

439
  """
440
  if fd is None:
441
    return
442

    
443
  if not err:
444
    err = "<unknown error>"
445

    
446
  utils_wrapper.RetryOnSignal(os.write, fd, err)
447

    
448

    
449
def _CheckIfAlive(child):
450
  """Raises L{utils_retry.RetryAgain} if child is still alive.
451

452
  @raises utils_retry.RetryAgain: If child is still alive
453

454
  """
455
  if child.poll() is None:
456
    raise utils_retry.RetryAgain()
457

    
458

    
459
def _WaitForProcess(child, timeout):
460
  """Waits for the child to terminate or until we reach timeout.
461

462
  """
463
  try:
464
    utils_retry.Retry(_CheckIfAlive, (1.0, 1.2, 5.0), max(0, timeout),
465
                      args=[child])
466
  except utils_retry.RetryTimeout:
467
    pass
468

    
469

    
470
def _RunCmdPipe(cmd, env, via_shell, cwd, interactive, timeout, noclose_fds,
471
                _linger_timeout=constants.CHILD_LINGER_TIMEOUT):
472
  """Run a command and return its output.
473

474
  @type  cmd: string or list
475
  @param cmd: Command to run
476
  @type env: dict
477
  @param env: The environment to use
478
  @type via_shell: bool
479
  @param via_shell: if we should run via the shell
480
  @type cwd: string
481
  @param cwd: the working directory for the program
482
  @type interactive: boolean
483
  @param interactive: Run command interactive (without piping)
484
  @type timeout: int
485
  @param timeout: Timeout after the programm gets terminated
486
  @type noclose_fds: list
487
  @param noclose_fds: list of additional (fd >=3) file descriptors to leave
488
                      open for the child process
489
  @rtype: tuple
490
  @return: (out, err, status)
491

492
  """
493
  poller = select.poll()
494

    
495
  stderr = subprocess.PIPE
496
  stdout = subprocess.PIPE
497
  stdin = subprocess.PIPE
498

    
499
  if interactive:
500
    stderr = stdout = stdin = None
501

    
502
  if noclose_fds:
503
    preexec_fn = lambda: CloseFDs(noclose_fds)
504
    close_fds = False
505
  else:
506
    preexec_fn = None
507
    close_fds = True
508

    
509
  child = subprocess.Popen(cmd, shell=via_shell,
510
                           stderr=stderr,
511
                           stdout=stdout,
512
                           stdin=stdin,
513
                           close_fds=close_fds, env=env,
514
                           cwd=cwd,
515
                           preexec_fn=preexec_fn)
516

    
517
  out = StringIO()
518
  err = StringIO()
519

    
520
  linger_timeout = None
521

    
522
  if timeout is None:
523
    poll_timeout = None
524
  else:
525
    poll_timeout = utils_algo.RunningTimeout(timeout, True).Remaining
526

    
527
  msg_timeout = ("Command %s (%d) run into execution timeout, terminating" %
528
                 (cmd, child.pid))
529
  msg_linger = ("Command %s (%d) run into linger timeout, killing" %
530
                (cmd, child.pid))
531

    
532
  timeout_action = _TIMEOUT_NONE
533

    
534
  if not interactive:
535
    child.stdin.close()
536
    poller.register(child.stdout, select.POLLIN)
537
    poller.register(child.stderr, select.POLLIN)
538
    fdmap = {
539
      child.stdout.fileno(): (out, child.stdout),
540
      child.stderr.fileno(): (err, child.stderr),
541
      }
542
    for fd in fdmap:
543
      utils_wrapper.SetNonblockFlag(fd, True)
544

    
545
    while fdmap:
546
      if poll_timeout:
547
        pt = poll_timeout() * 1000
548
        if pt < 0:
549
          if linger_timeout is None:
550
            logging.warning(msg_timeout)
551
            if child.poll() is None:
552
              timeout_action = _TIMEOUT_TERM
553
              utils_wrapper.IgnoreProcessNotFound(os.kill, child.pid,
554
                                                  signal.SIGTERM)
555
            linger_timeout = \
556
              utils_algo.RunningTimeout(_linger_timeout, True).Remaining
557
          pt = linger_timeout() * 1000
558
          if pt < 0:
559
            break
560
      else:
561
        pt = None
562

    
563
      pollresult = utils_wrapper.RetryOnSignal(poller.poll, pt)
564

    
565
      for fd, event in pollresult:
566
        if event & select.POLLIN or event & select.POLLPRI:
567
          data = fdmap[fd][1].read()
568
          # no data from read signifies EOF (the same as POLLHUP)
569
          if not data:
570
            poller.unregister(fd)
571
            del fdmap[fd]
572
            continue
573
          fdmap[fd][0].write(data)
574
        if (event & select.POLLNVAL or event & select.POLLHUP or
575
            event & select.POLLERR):
576
          poller.unregister(fd)
577
          del fdmap[fd]
578

    
579
  if timeout is not None:
580
    assert callable(poll_timeout)
581

    
582
    # We have no I/O left but it might still run
583
    if child.poll() is None:
584
      _WaitForProcess(child, poll_timeout())
585

    
586
    # Terminate if still alive after timeout
587
    if child.poll() is None:
588
      if linger_timeout is None:
589
        logging.warning(msg_timeout)
590
        timeout_action = _TIMEOUT_TERM
591
        utils_wrapper.IgnoreProcessNotFound(os.kill, child.pid, signal.SIGTERM)
592
        lt = _linger_timeout
593
      else:
594
        lt = linger_timeout()
595
      _WaitForProcess(child, lt)
596

    
597
    # Okay, still alive after timeout and linger timeout? Kill it!
598
    if child.poll() is None:
599
      timeout_action = _TIMEOUT_KILL
600
      logging.warning(msg_linger)
601
      utils_wrapper.IgnoreProcessNotFound(os.kill, child.pid, signal.SIGKILL)
602

    
603
  out = out.getvalue()
604
  err = err.getvalue()
605

    
606
  status = child.wait()
607
  return out, err, status, timeout_action
608

    
609

    
610
def _RunCmdFile(cmd, env, via_shell, output, cwd, noclose_fds):
611
  """Run a command and save its output to a file.
612

613
  @type  cmd: string or list
614
  @param cmd: Command to run
615
  @type env: dict
616
  @param env: The environment to use
617
  @type via_shell: bool
618
  @param via_shell: if we should run via the shell
619
  @type output: str
620
  @param output: the filename in which to save the output
621
  @type cwd: string
622
  @param cwd: the working directory for the program
623
  @type noclose_fds: list
624
  @param noclose_fds: list of additional (fd >=3) file descriptors to leave
625
                      open for the child process
626
  @rtype: int
627
  @return: the exit status
628

629
  """
630
  fh = open(output, "a")
631

    
632
  if noclose_fds:
633
    preexec_fn = lambda: CloseFDs(noclose_fds + [fh.fileno()])
634
    close_fds = False
635
  else:
636
    preexec_fn = None
637
    close_fds = True
638

    
639
  try:
640
    child = subprocess.Popen(cmd, shell=via_shell,
641
                             stderr=subprocess.STDOUT,
642
                             stdout=fh,
643
                             stdin=subprocess.PIPE,
644
                             close_fds=close_fds, env=env,
645
                             cwd=cwd,
646
                             preexec_fn=preexec_fn)
647

    
648
    child.stdin.close()
649
    status = child.wait()
650
  finally:
651
    fh.close()
652
  return status
653

    
654

    
655
def RunParts(dir_name, env=None, reset_env=False):
656
  """Run Scripts or programs in a directory
657

658
  @type dir_name: string
659
  @param dir_name: absolute path to a directory
660
  @type env: dict
661
  @param env: The environment to use
662
  @type reset_env: boolean
663
  @param reset_env: whether to reset or keep the default os environment
664
  @rtype: list of tuples
665
  @return: list of (name, (one of RUNDIR_STATUS), RunResult)
666

667
  """
668
  rr = []
669

    
670
  try:
671
    dir_contents = utils_io.ListVisibleFiles(dir_name)
672
  except OSError, err:
673
    logging.warning("RunParts: skipping %s (cannot list: %s)", dir_name, err)
674
    return rr
675

    
676
  for relname in sorted(dir_contents):
677
    fname = utils_io.PathJoin(dir_name, relname)
678
    if not (os.path.isfile(fname) and os.access(fname, os.X_OK) and
679
            constants.EXT_PLUGIN_MASK.match(relname) is not None):
680
      rr.append((relname, constants.RUNPARTS_SKIP, None))
681
    else:
682
      try:
683
        result = RunCmd([fname], env=env, reset_env=reset_env)
684
      except Exception, err: # pylint: disable-msg=W0703
685
        rr.append((relname, constants.RUNPARTS_ERR, str(err)))
686
      else:
687
        rr.append((relname, constants.RUNPARTS_RUN, result))
688

    
689
  return rr
690

    
691

    
692
def _GetProcStatusPath(pid):
693
  """Returns the path for a PID's proc status file.
694

695
  @type pid: int
696
  @param pid: Process ID
697
  @rtype: string
698

699
  """
700
  return "/proc/%d/status" % pid
701

    
702

    
703
def IsProcessAlive(pid):
704
  """Check if a given pid exists on the system.
705

706
  @note: zombie status is not handled, so zombie processes
707
      will be returned as alive
708
  @type pid: int
709
  @param pid: the process ID to check
710
  @rtype: boolean
711
  @return: True if the process exists
712

713
  """
714
  def _TryStat(name):
715
    try:
716
      os.stat(name)
717
      return True
718
    except EnvironmentError, err:
719
      if err.errno in (errno.ENOENT, errno.ENOTDIR):
720
        return False
721
      elif err.errno == errno.EINVAL:
722
        raise utils_retry.RetryAgain(err)
723
      raise
724

    
725
  assert isinstance(pid, int), "pid must be an integer"
726
  if pid <= 0:
727
    return False
728

    
729
  # /proc in a multiprocessor environment can have strange behaviors.
730
  # Retry the os.stat a few times until we get a good result.
731
  try:
732
    return utils_retry.Retry(_TryStat, (0.01, 1.5, 0.1), 0.5,
733
                             args=[_GetProcStatusPath(pid)])
734
  except utils_retry.RetryTimeout, err:
735
    err.RaiseInner()
736

    
737

    
738
def _ParseSigsetT(sigset):
739
  """Parse a rendered sigset_t value.
740

741
  This is the opposite of the Linux kernel's fs/proc/array.c:render_sigset_t
742
  function.
743

744
  @type sigset: string
745
  @param sigset: Rendered signal set from /proc/$pid/status
746
  @rtype: set
747
  @return: Set of all enabled signal numbers
748

749
  """
750
  result = set()
751

    
752
  signum = 0
753
  for ch in reversed(sigset):
754
    chv = int(ch, 16)
755

    
756
    # The following could be done in a loop, but it's easier to read and
757
    # understand in the unrolled form
758
    if chv & 1:
759
      result.add(signum + 1)
760
    if chv & 2:
761
      result.add(signum + 2)
762
    if chv & 4:
763
      result.add(signum + 3)
764
    if chv & 8:
765
      result.add(signum + 4)
766

    
767
    signum += 4
768

    
769
  return result
770

    
771

    
772
def _GetProcStatusField(pstatus, field):
773
  """Retrieves a field from the contents of a proc status file.
774

775
  @type pstatus: string
776
  @param pstatus: Contents of /proc/$pid/status
777
  @type field: string
778
  @param field: Name of field whose value should be returned
779
  @rtype: string
780

781
  """
782
  for line in pstatus.splitlines():
783
    parts = line.split(":", 1)
784

    
785
    if len(parts) < 2 or parts[0] != field:
786
      continue
787

    
788
    return parts[1].strip()
789

    
790
  return None
791

    
792

    
793
def IsProcessHandlingSignal(pid, signum, status_path=None):
794
  """Checks whether a process is handling a signal.
795

796
  @type pid: int
797
  @param pid: Process ID
798
  @type signum: int
799
  @param signum: Signal number
800
  @rtype: bool
801

802
  """
803
  if status_path is None:
804
    status_path = _GetProcStatusPath(pid)
805

    
806
  try:
807
    proc_status = utils_io.ReadFile(status_path)
808
  except EnvironmentError, err:
809
    # In at least one case, reading /proc/$pid/status failed with ESRCH.
810
    if err.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL, errno.ESRCH):
811
      return False
812
    raise
813

    
814
  sigcgt = _GetProcStatusField(proc_status, "SigCgt")
815
  if sigcgt is None:
816
    raise RuntimeError("%s is missing 'SigCgt' field" % status_path)
817

    
818
  # Now check whether signal is handled
819
  return signum in _ParseSigsetT(sigcgt)
820

    
821

    
822
def Daemonize(logfile):
823
  """Daemonize the current process.
824

825
  This detaches the current process from the controlling terminal and
826
  runs it in the background as a daemon.
827

828
  @type logfile: str
829
  @param logfile: the logfile to which we should redirect stdout/stderr
830
  @rtype: int
831
  @return: the value zero
832

833
  """
834
  # pylint: disable-msg=W0212
835
  # yes, we really want os._exit
836

    
837
  # TODO: do another attempt to merge Daemonize and StartDaemon, or at
838
  # least abstract the pipe functionality between them
839

    
840
  # Create pipe for sending error messages
841
  (rpipe, wpipe) = os.pipe()
842

    
843
  # this might fail
844
  pid = os.fork()
845
  if (pid == 0):  # The first child.
846
    SetupDaemonEnv()
847

    
848
    # this might fail
849
    pid = os.fork() # Fork a second child.
850
    if (pid == 0):  # The second child.
851
      utils_wrapper.CloseFdNoError(rpipe)
852
    else:
853
      # exit() or _exit()?  See below.
854
      os._exit(0) # Exit parent (the first child) of the second child.
855
  else:
856
    utils_wrapper.CloseFdNoError(wpipe)
857
    # Wait for daemon to be started (or an error message to
858
    # arrive) and read up to 100 KB as an error message
859
    errormsg = utils_wrapper.RetryOnSignal(os.read, rpipe, 100 * 1024)
860
    if errormsg:
861
      sys.stderr.write("Error when starting daemon process: %r\n" % errormsg)
862
      rcode = 1
863
    else:
864
      rcode = 0
865
    os._exit(rcode) # Exit parent of the first child.
866

    
867
  SetupDaemonFDs(logfile, None)
868
  return wpipe
869

    
870

    
871
def KillProcess(pid, signal_=signal.SIGTERM, timeout=30,
872
                waitpid=False):
873
  """Kill a process given by its pid.
874

875
  @type pid: int
876
  @param pid: The PID to terminate.
877
  @type signal_: int
878
  @param signal_: The signal to send, by default SIGTERM
879
  @type timeout: int
880
  @param timeout: The timeout after which, if the process is still alive,
881
                  a SIGKILL will be sent. If not positive, no such checking
882
                  will be done
883
  @type waitpid: boolean
884
  @param waitpid: If true, we should waitpid on this process after
885
      sending signals, since it's our own child and otherwise it
886
      would remain as zombie
887

888
  """
889
  def _helper(pid, signal_, wait):
890
    """Simple helper to encapsulate the kill/waitpid sequence"""
891
    if utils_wrapper.IgnoreProcessNotFound(os.kill, pid, signal_) and wait:
892
      try:
893
        os.waitpid(pid, os.WNOHANG)
894
      except OSError:
895
        pass
896

    
897
  if pid <= 0:
898
    # kill with pid=0 == suicide
899
    raise errors.ProgrammerError("Invalid pid given '%s'" % pid)
900

    
901
  if not IsProcessAlive(pid):
902
    return
903

    
904
  _helper(pid, signal_, waitpid)
905

    
906
  if timeout <= 0:
907
    return
908

    
909
  def _CheckProcess():
910
    if not IsProcessAlive(pid):
911
      return
912

    
913
    try:
914
      (result_pid, _) = os.waitpid(pid, os.WNOHANG)
915
    except OSError:
916
      raise utils_retry.RetryAgain()
917

    
918
    if result_pid > 0:
919
      return
920

    
921
    raise utils_retry.RetryAgain()
922

    
923
  try:
924
    # Wait up to $timeout seconds
925
    utils_retry.Retry(_CheckProcess, (0.01, 1.5, 0.1), timeout)
926
  except utils_retry.RetryTimeout:
927
    pass
928

    
929
  if IsProcessAlive(pid):
930
    # Kill process if it's still alive
931
    _helper(pid, signal.SIGKILL, waitpid)
932

    
933

    
934
def RunInSeparateProcess(fn, *args):
935
  """Runs a function in a separate process.
936

937
  Note: Only boolean return values are supported.
938

939
  @type fn: callable
940
  @param fn: Function to be called
941
  @rtype: bool
942
  @return: Function's result
943

944
  """
945
  pid = os.fork()
946
  if pid == 0:
947
    # Child process
948
    try:
949
      # In case the function uses temporary files
950
      utils_wrapper.ResetTempfileModule()
951

    
952
      # Call function
953
      result = int(bool(fn(*args)))
954
      assert result in (0, 1)
955
    except: # pylint: disable-msg=W0702
956
      logging.exception("Error while calling function in separate process")
957
      # 0 and 1 are reserved for the return value
958
      result = 33
959

    
960
    os._exit(result) # pylint: disable-msg=W0212
961

    
962
  # Parent process
963

    
964
  # Avoid zombies and check exit code
965
  (_, status) = os.waitpid(pid, 0)
966

    
967
  if os.WIFSIGNALED(status):
968
    exitcode = None
969
    signum = os.WTERMSIG(status)
970
  else:
971
    exitcode = os.WEXITSTATUS(status)
972
    signum = None
973

    
974
  if not (exitcode in (0, 1) and signum is None):
975
    raise errors.GenericError("Child program failed (code=%s, signal=%s)" %
976
                              (exitcode, signum))
977

    
978
  return bool(exitcode)
979

    
980

    
981
def CloseFDs(noclose_fds=None):
982
  """Close file descriptors.
983

984
  This closes all file descriptors above 2 (i.e. except
985
  stdin/out/err).
986

987
  @type noclose_fds: list or None
988
  @param noclose_fds: if given, it denotes a list of file descriptor
989
      that should not be closed
990

991
  """
992
  # Default maximum for the number of available file descriptors.
993
  if 'SC_OPEN_MAX' in os.sysconf_names:
994
    try:
995
      MAXFD = os.sysconf('SC_OPEN_MAX')
996
      if MAXFD < 0:
997
        MAXFD = 1024
998
    except OSError:
999
      MAXFD = 1024
1000
  else:
1001
    MAXFD = 1024
1002

    
1003
  maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
1004
  if (maxfd == resource.RLIM_INFINITY):
1005
    maxfd = MAXFD
1006

    
1007
  # Iterate through and close all file descriptors (except the standard ones)
1008
  for fd in range(3, maxfd):
1009
    if noclose_fds and fd in noclose_fds:
1010
      continue
1011
    utils_wrapper.CloseFdNoError(fd)