Bug 711102 Ensure build environments have logging modules for peptest r=ctalbert

testing/mozbase/mozhttpd/mozhttpd/mozhttpd.py

@@ -48,9 +48,9 @@ from SocketServer import ThreadingMixIn
 
 class EasyServer(ThreadingMixIn, BaseHTTPServer.HTTPServer):
     allow_reuse_address = True
-    
+
 class MozRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
-    docroot = os.getcwd()
+    docroot = os.getcwd() # current working directory at time of import
 
     def parse_request(self):
         retval = SimpleHTTPServer.SimpleHTTPRequestHandler.parse_request(self)

testing/mozbase/mozhttpd/setup.py

@@ -58,7 +58,6 @@ setup(name='mozhttpd',
       author_email='tools@lists.mozilla.org',
       url='https://github.com/mozilla/mozbase/tree/master/mozhttpd',
       license='MPL',
-      py_modules=['mozhttpd'],
       packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
       include_package_data=True,
       zip_safe=False,

testing/mozbase/mozlog/mozlog/logger.py

@@ -35,6 +35,10 @@
 # ***** END LICENSE BLOCK *****
 from logging import getLogger as getSysLogger
 from logging import *
+# Some of the build slave environments don't see the following when doing
+# 'from logging import *'
+# see https://bugzilla.mozilla.org/show_bug.cgi?id=700415#c35
+from logging import getLoggerClass, addLevelName, setLoggerClass
 
 _default_level = INFO
 _LoggerClass = getLoggerClass()

testing/mozbase/mozprocess/README.md

@@ -1,5 +1,5 @@
 [mozprocess](https://github.com/mozilla/mozbase/tree/master/mozprocess)
-provides python process management via an operating system 
+provides python process management via an operating system
 and platform transparent interface to Mozilla platforms of interest.
 Mozprocess aims to provide the ability
 to robustly terminate a process (by timeout or otherwise), along with
@@ -19,16 +19,87 @@ Basic usage:
     process = ProcessHandler(['command', '-line', 'arguments'],
                              cwd=None, # working directory for cmd; defaults to None
                              env={},   # environment to use for the process; defaults to os.environ
-                             )         
+                             )
     exit_code = process.waitForFinish(timeout=60) # seconds
 
-See an example in https://github.com/mozilla/mozbase/blob/master/mutt/mutt/tests/python/testprofilepath.py
+`ProcessHandler` offers several other properties and methods as part of its API:
+
+    @property
+    def timedOut(self):
+        """True if the process has timed out."""
+
+    def run(self):
+        """
+        Starts the process. waitForFinish must be called to allow the
+        process to complete.
+        """
+
+    def kill(self):
+        """
+        Kills the managed process and if you created the process with
+        'ignore_children=False' (the default) then it will also
+        also kill all child processes spawned by it.
+        If you specified 'ignore_children=True' when creating the process,
+        only the root process will be killed.
+
+        Note that this does not manage any state, save any output etc,
+        it immediately kills the process.
+        """
+
+    def readWithTimeout(self, f, timeout):
+        """
+        Try to read a line of output from the file object |f|.
+        |f| must be a pipe, like the |stdout| member of a subprocess.Popen
+        object created with stdout=PIPE. If no output
+        is received within |timeout| seconds, return a blank line.
+        Returns a tuple (line, did_timeout), where |did_timeout| is True
+        if the read timed out, and False otherwise.
+
+        Calls a private member because this is a different function based on
+        the OS
+        """
+
+    def processOutputLine(self, line):
+        """Called for each line of output that a process sends to stdout/stderr."""
+        for handler in self.processOutputLineHandlers:
+            handler(line)
+
+    def onTimeout(self):
+        """Called when a process times out."""
+        for handler in self.onTimeoutHandlers:
+            handler()
+
+    def onFinish(self):
+        """Called when a process finishes without a timeout."""
+        for handler in self.onFinishHandlers:
+            handler()
+
+    def waitForFinish(self, timeout=None, outputTimeout=None):
+        """
+        Handle process output until the process terminates or times out.
+
+        If timeout is not None, the process will be allowed to continue for
+        that number of seconds before being killed.
+
+        If outputTimeout is not None, the process will be allowed to continue
+        for that number of seconds without producing any output before
+        being killed.
+        """
+
+See https://github.com/mozilla/mozbase/blob/master/mozprocess/mozprocess/processhandler.py
+for the python implementation.
+
+`ProcessHandler` extends `ProcessHandlerMixin` which by default prints the
+output, logs to a file (if specified), and stores the output (if specified, by
+default `True`).  `ProcessHandlerMixin`, by default, does none of these things
+and has no handlers for `onTimeout`, `processOutput`, or `onFinish`.
 
 `ProcessHandler` may be subclassed to handle process timeouts (by overriding
-the `onTimeout()` method), process completion (by overriding 
-`onFinish()`), and to process the command output (by overriding 
+the `onTimeout()` method), process completion (by overriding
+`onFinish()`), and to process the command output (by overriding
 `processOutputLine()`).
 
 # TODO
 
 - Document improvements over `subprocess.Popen.kill`
+- Introduce test the show improvements over `subprocess.Popen.kill`