Make os.waitpid timeout on Windows.

scripts/slave/recipe_modules/goma/resources/cloudtail_utils.py

 #!/usr/bin/env python
 # Copyright (c) 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import argparse
 import errno
+import multiprocessing
 import os
 import signal
 import subprocess
 import sys
 import time
 
 from slave import goma_utils
 
 
 def start_cloudtail(args):
@@ skipping 24 matching lines @@
 
   try:
     os.kill(pid, 0)
   except OSError as e:
     if e.errno == errno.ESRCH or e.errno == errno.EPERM:
       return False
     raise e
   return True
 
 
+def waitpid_for_win(pid):
+  """Return exception if raised in os.waitpid, or None.
+
+  Args:
+    pid(int): pid of process which this function checks
+              whether it is running or not.
+
+  Returns:
+    Exception: if something raised in os.waitpid.
+    None: Otherwise.
+  """
+  try:
+    os.waitpid(pid, 0)
+  except Exception as e:
+    return e
+  return None
+
+
 class NotDiedError(Exception):
   def __str__(self):
     return "NotDiedError"
 
 
 def wait_termination(pid):
   """Send SIGINT to pid and wait termination of pid.
 
   Args:
     pid(int): pid of process which this function waits termination.
 
   Raises:
     OSError: is_running_posix, os.waitpid and os.kill may throw OSError.
     NotDiedError: if cloudtail is running after 10 seconds waiting,
                   NotDiedError is raised.
   """
 
   try:
     os.kill(pid, signal.SIGINT)

[Vadim Sh., 2016/10/21 03:01:48]

I've just discovered that on Windows this doesn't actually work. It appears to
be killing the process right away (at least that's what I see when I try
os.kill(pid, signal.SIGINT) on Windows).

See
http://stackoverflow.com/questions/7085604/sending-c-to-python-subprocess-obj...

So I don't understand how waitpid can get stuck. The only possibility is that
the PID got assigned to some other process immediately. 

Actually, I've just realized that os.waitpid() required to pass a handle to the
process, not PID (as the doc clearly states). I've confirmed it by grabbing a
handle via win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION |
win32con.SYNCHRONIZE, False, <pid>) and passing it to os.waitpid. It blocks (as
it should). When I try to pass PID directly, it just says "No child process".

   except OSError as e:
     # Already dead?
     if e.errno in (errno.ECHILD, errno.EPERM, errno.ESRCH):
       print('Can\'t send SIGINT to process %d. Already dead? Errno %d.' %
             (pid, e.errno))
       return
     raise
 
   print('SIGINT has been sent to process %d. '
         'Going to wait for the process finishes.' % pid)
   if os.name == 'nt':
+    pool = multiprocessing.Pool(1)
+    res = pool.apply_async(waitpid_for_win)
     try:
-      os.waitpid(pid, 0)
-    except OSError as e:
-      if e.errno == errno.ECHILD:
-        print('process %d died before waitpitd' % pid)
-        return
-      raise e
+      e = res.get(10)
+    except multiprocessing.TimeoutError:
+      print('process %d running more than 10 seconds' % pid)
+      raise NotDiedError()
+    if e is None:
+      return
+    if isinstance(e, OSError) and e.errno == errno.ECHILD:
+      print('process %d died before waitpitd' % pid)
+      return
+    raise e
   else:
     for _ in xrange(10):
       time.sleep(1)
       if not is_running_posix(pid):
         return
 
     print('process %d running more than 10 seconds' % pid)
     raise NotDiedError()
 
 
@@ skipping 34 matching lines @@
       try:
         os.kill(pid, signal.SIGTERM)
       except OSError as e:
         print('Failed to send SIGTERM to process %d: %s' % (pid, e))
       # We do not reraise because I believe not suspending the process
       # is more important than completely killing cloudtail.
 
 
 if '__main__' == __name__:
   sys.exit(main())