Roll //build, //native_client, and a few more targets of opportunity.

testing/legion/process.py

 # Copyright 2015 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.
 
-"""Defines the task RPC methods."""
+"""RPC compatible subprocess-type module.
 
-import os
+This module defined both a task-side process class as well as a controller-side
+process wrapper for easier access and usage of the task-side process.
+"""
+
+import logging
+import subprocess
 import sys
-import logging
 import threading
 
 #pylint: disable=relative-import
 import common_lib
 
 # Map swarming_client to use subprocess42
 sys.path.append(common_lib.SWARMING_DIR)
 
 from utils import subprocess42
 
 
-class RPCMethods(object):
-  """Class exposing RPC methods."""
+class ControllerProcessWrapper(object):
+  """Controller-side process wrapper class.
 
-  _dotted_whitelist = ['subprocess']
+  This class provides a more intuitive interface to task-side processes
+  than calling the methods directly using the RPC object.
+  """
 
-  def __init__(self, server):
-    self._server = server
-    self.subprocess = Subprocess
+  def __init__(self, rpc, cmd, verbose=False, detached=False, cwd=None):
+    self._rpc = rpc
+    self._id = rpc.subprocess.Process(cmd)
+    if verbose:
+      self._rpc.subprocess.SetVerbose(self._id)
+    if detached:
+      self._rpc.subprocess.SetDetached(self._id)
+    if cwd:
+      self._rpc.subprocess.SetCwd(self._rpc, cwd)
+    self._rpc.subprocess.Start(self._id)
 
-  def _dispatch(self, method, params):
-    obj = self
-    if '.' in method:
-      # Allow only white listed dotted names
-      name, method = method.split('.')
-      assert name in self._dotted_whitelist
-      obj = getattr(self, name)
-    return getattr(obj, method)(*params)
+  def Terminate(self):
+    logging.debug('Terminating process %s', self._id)
+    return self._rpc.subprocess.Terminate(self._id)
 
-  def Echo(self, message):
-    """Simple RPC method to print and return a message."""
-    logging.info('Echoing %s', message)
-    return 'echo %s' % str(message)
+  def Kill(self):
+    logging.debug('Killing process %s', self._id)
+    self._rpc.subprocess.Kill(self._id)
 
-  def AbsPath(self, path):
-    """Returns the absolute path."""
-    return os.path.abspath(path)
+  def Delete(self):
+    return self._rpc.subprocess.Delete(self._id)
 
-  def Quit(self):
-    """Call _server.shutdown in another thread.
+  def GetReturncode(self):
+    return self._rpc.subprocess.GetReturncode(self._id)
 
-    This is needed because server.shutdown waits for the server to actually
-    quit. However the server cannot shutdown until it completes handling this
-    call. Calling this in the same thread results in a deadlock.
+  def ReadStdout(self):
+    """Returns all stdout since the last call to ReadStdout.
+
+    This call allows the user to read stdout while the process is running.
+    However each call will flush the local stdout buffer. In order to make
+    multiple calls to ReadStdout and to retain the entire output the results
+    of this call will need to be buffered in the calling code.
     """
-    t = threading.Thread(target=self._server.shutdown)
-    t.start()
+    return self._rpc.subprocess.ReadStdout(self._id)
+
+  def ReadStderr(self):
+    """Returns all stderr read since the last call to ReadStderr.
+
+    See ReadStdout for additional details.
+    """
+    return self._rpc.subprocess.ReadStderr(self._id)
+
+  def ReadOutput(self):
+    """Returns the (stdout, stderr) since the last Read* call.
+
+    See ReadStdout for additional details.
+    """
+    return self._rpc.subprocess.ReadOutput(self._id)
+
+  def Wait(self):
+    return self._rpc.subprocess.Wait(self._id)
+
+  def Poll(self):
+    return self._rpc.subprocess.Poll(self._id)
+
+  def GetPid(self):
+    return self._rpc.subprocess.GetPid(self._id)
 
 
-class Subprocess(object):
-  """Implements a server-based non-blocking subprocess.
+
+class Process(object):
+  """Implements a task-side non-blocking subprocess.
 
   This non-blocking subprocess allows the caller to continue operating while
   also able to interact with this subprocess based on a key returned to
   the caller at the time of creation.
 
   Creation args are set via Set* methods called after calling Process but
   before calling Start. This is due to a limitation of the XML-RPC
   implementation not supporting keyword arguments.
   """
 
@@ skipping 30 matching lines @@
   @classmethod
   def KillAll(cls):
     for key in cls._processes:
       cls.Kill(key)
 
   @classmethod
   def Process(cls, cmd):
     with cls._creation_lock:
       key = 'Process%d' % cls._process_next_id
       cls._process_next_id += 1
-    logging.debug('Creating process %s', key)
+    logging.debug('Creating process %s with cmd %r', key, cmd)
     process = cls(cmd)
     cls._processes[key] = process
     return key
 
   def _Start(self):
     logging.info('Starting process %s', self)
     self.proc = subprocess42.Popen(self.cmd, stdout=subprocess42.PIPE,
                                    stderr=subprocess42.PIPE,
                                    detached=self.detached, cwd=self.cwd)
     threading.Thread(target=self._reader).start()
 
   @classmethod
   def Start(cls, key):
     cls._processes[key]._Start()
 
   @classmethod
   def SetCwd(cls, key, cwd):
     """Sets the process's cwd."""
     logging.debug('Setting %s cwd to %s', key, cwd)
     cls._processes[key].cwd = cwd
 
   @classmethod
   def SetDetached(cls, key):
     """Creates a detached process."""
-    logging.debug('Setting %s to run detached', key)
+    logging.debug('Setting %s.detached = True', key)
     cls._processes[key].detached = True
 
   @classmethod
   def SetVerbose(cls, key):
     """Sets the stdout and stderr to be emitted locally."""
-    logging.debug('Setting %s to be verbose', key)
+    logging.debug('Setting %s.verbose = True', key)
     cls._processes[key].verbose = True
 
   @classmethod
   def Terminate(cls, key):
     logging.debug('Terminating process %s', key)
     cls._processes[key].proc.terminate()
 
   @classmethod
   def Kill(cls, key):
     logging.debug('Killing process %s', key)
@@ skipping 52 matching lines @@
   def Wait(cls, key):
     return cls._processes[key].proc.wait()
 
   @classmethod
   def Poll(cls, key):
     return cls._processes[key].proc.poll()
 
   @classmethod
   def GetPid(cls, key):
     return cls._processes[key].proc.pid