Use a single Python Forwarder instance for each base test runner instance.

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
-from forwarder import Forwarder
 import ports
 
 
 # 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.CHROME_DIR, 'third_party'),
        os.path.join(constants.CHROME_DIR, 'third_party', 'tlslite'),
        os.path.join(constants.CHROME_DIR, 'third_party', 'pyftpdlib', 'src'),
        os.path.join(constants.CHROME_DIR, 'net', 'tools', 'testserver'),
        os.path.join(constants.CHROME_DIR, 'sync', 'tools', 'testserver')))
@@ skipping 57 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, build_type):
+  def __init__(self, ready_event, arguments, adb, tool, forwarder, 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 = None
+    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 97 matching lines @@
       command = [os.path.join(command, 'net', 'tools', 'testserver',
                               'testserver.py')] + self.command_line
     logging.info('Running: %s', command)
     self.process = subprocess.Popen(command)
     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 = Forwarder(self.adb, self.build_type)
       self._test_server_forwarder.Run(
           [(0, self.host_port)], self.tool, '127.0.0.1')
       # Check whether the forwarder is ready on the device.
       self.is_ready = False
       device_port = self._test_server_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()
-    if self._test_server_forwarder:
-      self._test_server_forwarder.UnmapDevicePort(self.forwarder_device_port)
+    self._test_server_forwarder.UnmapDevicePort(self.forwarder_device_port)
     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, build_type):
+  def __init__(self, test_server_spawner_port, adb, tool, forwarder,
+               build_type):
     logging.info('Creating new spawner on port: %d.', test_server_spawner_port)
     self.server = BaseHTTPServer.HTTPServer(('', test_server_spawner_port),
                                             SpawningServerRequestHandler)
-    self.port = test_server_spawner_port
     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