Reland r212020: Move Python setup/tear down logic into Forwarder ...

build/android/pylib/chrome_test_server_spawner.py

 # Copyright 2013 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.
 
 """A "Test Server Spawner" that handles killing/stopping per-test test servers.
 
 It's used to accept requests from the device to spawn and kill instances of the
 chrome test server on the host.
 """
 
 import BaseHTTPServer
 import json
 import logging
 import os
 import select
 import struct
 import subprocess
 import sys
 import threading
 import time
 import urlparse
 
 import constants
 import ports
 
+from pylib.forwarder import Forwarder
 
 # Path that are needed to import necessary modules when launching a testserver.
 os.environ['PYTHONPATH'] = os.environ.get('PYTHONPATH', '') + (':%s:%s:%s:%s:%s'
     % (os.path.join(constants.DIR_SOURCE_ROOT, 'third_party'),
        os.path.join(constants.DIR_SOURCE_ROOT, 'third_party', 'tlslite'),
        os.path.join(constants.DIR_SOURCE_ROOT, 'third_party', 'pyftpdlib',
                     'src'),
        os.path.join(constants.DIR_SOURCE_ROOT, 'net', 'tools', 'testserver'),
        os.path.join(constants.DIR_SOURCE_ROOT, 'sync', 'tools', 'testserver')))
 
@@ skipping 56 matching lines @@
     raise NotImplementedError('Unknown server type: %s' % server_type)
   if server_type == 'udpecho':
     raise Exception('Please do not run UDP echo tests because we do not have '
                     'a UDP forwarder tool.')
   return SERVER_TYPES[server_type]
 
 
 class TestServerThread(threading.Thread):
   """A thread to run the test server in a separate process."""
 
-  def __init__(self, ready_event, arguments, adb, tool, forwarder, build_type):
+  def __init__(self, ready_event, arguments, adb, tool, build_type):
     """Initialize TestServerThread with the following argument.
 
     Args:
       ready_event: event which will be set when the test server is ready.
       arguments: dictionary of arguments to run the test server.
       adb: instance of AndroidCommands.
       tool: instance of runtime error detection tool.
-      forwarder: instance of Forwarder.
       build_type: 'Release' or 'Debug'.
     """
     threading.Thread.__init__(self)
     self.wait_event = threading.Event()
     self.stop_flag = False
     self.ready_event = ready_event
     self.ready_event.clear()
     self.arguments = arguments
     self.adb = adb
     self.tool = tool
     self.test_server_process = None
     self.is_ready = False
     self.host_port = self.arguments['port']
     assert isinstance(self.host_port, int)
-    self._test_server_forwarder = forwarder
     # The forwarder device port now is dynamically allocated.
     self.forwarder_device_port = 0
     # Anonymous pipe in order to get port info from test server.
     self.pipe_in = None
     self.pipe_out = None
     self.command_line = []
     self.build_type = build_type
 
   def _WaitToStartAndGetPortFromTestServer(self):
     """Waits for the Python test server to start and gets the port it is using.
@@ skipping 78 matching lines @@
         self.command_line.append('--tls-intolerant=%s' %
                                  self.arguments['tls-intolerant'])
       if self.arguments.has_key('ssl-client-ca'):
         for ca in self.arguments['ssl-client-ca']:
           self.command_line.append('--ssl-client-ca=%s' %
                                    os.path.join(constants.DIR_SOURCE_ROOT, ca))
       if self.arguments.has_key('ssl-bulk-cipher'):
         for bulk_cipher in self.arguments['ssl-bulk-cipher']:
           self.command_line.append('--ssl-bulk-cipher=%s' % bulk_cipher)
 
+  def _CloseUnnecessaryFDsForTestServerProcess(self):
+    # This is required to avoid subtle deadlocks that could be caused by the
+    # test server child process inheriting undesirable file descriptors such as
+    # file lock file descriptors.
+    for fd in xrange(0, 1024):
+      if fd != self.pipe_out:
+        try:
+          os.close(fd)
+        except:
+          pass
+
   def run(self):
     logging.info('Start running the thread!')
     self.wait_event.clear()
     self._GenerateCommandLineArguments()
     command = constants.DIR_SOURCE_ROOT
     if self.arguments['server-type'] == 'sync':
       command = [os.path.join(command, 'sync', 'tools', 'testserver',
                               'sync_testserver.py')] + self.command_line
     else:
       command = [os.path.join(command, 'net', 'tools', 'testserver',
                               'testserver.py')] + self.command_line
     logging.info('Running: %s', command)
-    self.process = subprocess.Popen(command)
+    self.process = subprocess.Popen(
+        command, preexec_fn=self._CloseUnnecessaryFDsForTestServerProcess)
     if self.process:
       if self.pipe_out:
         self.is_ready = self._WaitToStartAndGetPortFromTestServer()
       else:
         self.is_ready = _CheckPortStatus(self.host_port, True)
     if self.is_ready:
-      self._test_server_forwarder.Run([(0, self.host_port)], self.tool)
+      Forwarder.Map([(0, self.host_port)], self.adb, self.build_type, self.tool)
       # Check whether the forwarder is ready on the device.
       self.is_ready = False
-      device_port = self._test_server_forwarder.DevicePortForHostPort(
-          self.host_port)
+      device_port = Forwarder.DevicePortForHostPort(self.host_port)
       if device_port and _CheckDevicePortStatus(self.adb, device_port):
         self.is_ready = True
         self.forwarder_device_port = device_port
     # Wake up the request handler thread.
     self.ready_event.set()
     # Keep thread running until Stop() gets called.
     _WaitUntil(lambda: self.stop_flag, max_attempts=sys.maxint)
     if self.process.poll() is None:
       self.process.kill()
-    self._test_server_forwarder.UnmapDevicePort(self.forwarder_device_port)
+    Forwarder.UnmapDevicePort(self.forwarder_device_port, self.adb)
     self.process = None
     self.is_ready = False
     if self.pipe_out:
       os.close(self.pipe_in)
       os.close(self.pipe_out)
       self.pipe_in = None
       self.pipe_out = None
     logging.info('Test-server has died.')
     self.wait_event.set()
 
@@ skipping 49 matching lines @@
     logging.info(content_length)
     test_server_argument_json = self.rfile.read(content_length)
     logging.info(test_server_argument_json)
     assert not self.server.test_server_instance
     ready_event = threading.Event()
     self.server.test_server_instance = TestServerThread(
         ready_event,
         json.loads(test_server_argument_json),
         self.server.adb,
         self.server.tool,
-        self.server.forwarder,
         self.server.build_type)
     self.server.test_server_instance.setDaemon(True)
     self.server.test_server_instance.start()
     ready_event.wait()
     if self.server.test_server_instance.is_ready:
       self._SendResponse(200, 'OK', {}, json.dumps(
           {'port': self.server.test_server_instance.forwarder_device_port,
            'message': 'started'}))
       logging.info('Test server is running on port: %d.',
                    self.server.test_server_instance.host_port)
@@ skipping 47 matching lines @@
       self._SendResponse(200, 'OK', {}, 'ready')
       logging.info('Handled ping request and sent response.')
     else:
       self._SendResponse(400, 'Unknown request', {}, '')
       logging.info('Encounter unknown request: %s.', action)
 
 
 class SpawningServer(object):
   """The class used to start/stop a http server."""
 
-  def __init__(self, test_server_spawner_port, adb, tool, forwarder,
-               build_type):
+  def __init__(self, test_server_spawner_port, adb, tool, build_type):
     logging.info('Creating new spawner on port: %d.', test_server_spawner_port)
     self.server = BaseHTTPServer.HTTPServer(('', test_server_spawner_port),
                                             SpawningServerRequestHandler)
     self.server.adb = adb
     self.server.tool = tool
-    self.server.forwarder = forwarder
     self.server.test_server_instance = None
     self.server.build_type = build_type
 
   def _Listen(self):
     logging.info('Starting test server spawner')
     self.server.serve_forever()
 
   def Start(self):
     """Starts the test server spawner."""
     listener_thread = threading.Thread(target=self._Listen)
@@ skipping 10 matching lines @@
 
   def CleanupState(self):
     """Cleans up the spawning server state.
 
     This should be called if the test server spawner is reused,
     to avoid sharing the test server instance.
     """
     if self.server.test_server_instance:
       self.server.test_server_instance.Stop()
       self.server.test_server_instance = None