Make host port availability detection more robust.

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.
 """
 # pylint: disable=W0702
@@ skipping 46 matching lines @@
   """
   sleep_time_sec = 0.025
   for _ in xrange(1, max_attempts):
     if predicate():
       return True
     time.sleep(sleep_time_sec)
     sleep_time_sec = min(1, sleep_time_sec * 2)  # Don't wait more than 1 sec.
   return False
 
 
-def _CheckPortStatus(port, expected_status):
-  """Returns True if port has expected_status.
+def _CheckPortAvailable(port):
+  """Returns True if |port| is available."""
+  return _WaitUntil(lambda: ports.IsHostPortAvailable(port))
 
-  Args:
-    port: the port number.
-    expected_status: boolean of expected status.
 
-  Returns:
-    Returns True if the status is expected. Otherwise returns False.
-  """
-  return _WaitUntil(lambda: ports.IsHostPortUsed(port) == expected_status)
+def _CheckPortNotAvailable(port):
+  """Returns True if |port| is not available."""
+  return _WaitUntil(lambda: not ports.IsHostPortAvailable(port))
 
 
 def _CheckDevicePortStatus(device, port):
   """Returns whether the provided port is used."""
   return _WaitUntil(lambda: ports.IsDevicePortUsed(device, port))
 
 
 def _GetServerTypeCommandLine(server_type):
   """Returns the command-line by the given server type.
 
@@ skipping 72 matching lines @@
       logging.error('Failed to get length of server data.')
       return False
     port_json = os.read(self.pipe_in, data_length)
     if not port_json:
       logging.error('Failed to get server data.')
       return False
     logging.info('Got port json data: %s', port_json)
     port_json = json.loads(port_json)
     if port_json.has_key('port') and isinstance(port_json['port'], int):
       self.host_port = port_json['port']
-      return _CheckPortStatus(self.host_port, True)
+      return _CheckPortNotAvailable(self.host_port)
     logging.error('Failed to get port information from the server data.')
     return False
 
   def _GenerateCommandLineArguments(self):
     """Generates the command line to run the test server.
 
     Note that all options are processed by following the definitions in
     testserver.py.
     """
     if self.command_line:
@@ skipping 48 matching lines @@
     logging.info('Running: %s', command)
     # Pass DIR_SOURCE_ROOT as the child's working directory so that relative
     # paths in the arguments are resolved correctly.
     self.process = subprocess.Popen(
         command, preexec_fn=self._CloseUnnecessaryFDsForTestServerProcess,
         cwd=constants.DIR_SOURCE_ROOT)
     if self.process:
       if self.pipe_out:
         self.is_ready = self._WaitToStartAndGetPortFromTestServer()
       else:
-        self.is_ready = _CheckPortStatus(self.host_port, True)
+        self.is_ready = _CheckPortNotAvailable(self.host_port)
     if self.is_ready:
       Forwarder.Map([(0, self.host_port)], self.device, self.tool)
       # Check whether the forwarder is ready on the device.
       self.is_ready = False
       device_port = Forwarder.DevicePortForHostPort(self.host_port)
       if device_port and _CheckDevicePortStatus(self.device, device_port):
         self.is_ready = True
         self.forwarder_device_port = device_port
     # Wake up the request handler thread.
     self.ready_event.set()
@@ skipping 89 matching lines @@
   def _KillTestServer(self):
     """Stops the test server instance."""
     # There should only ever be one test server at a time. This may do the
     # wrong thing if we try and start multiple test servers.
     if not self.server.test_server_instance:
       return
     port = self.server.test_server_instance.host_port
     logging.info('Handling request to kill a test server on port: %d.', port)
     self.server.test_server_instance.Stop()
     # Make sure the status of test server is correct before sending response.
-    if _CheckPortStatus(port, False):
+    if _CheckPortAvailable(port):
       self._SendResponse(200, 'OK', {}, 'killed')
       logging.info('Test server on port %d is killed', port)
     else:
       self._SendResponse(500, 'Test Server Error.', {}, '')
       logging.info('Encounter problem during killing a test server.')
     self.server.test_server_instance = None
 
   def do_POST(self):
     parsed_path = urlparse.urlparse(self.path)
     action = parsed_path.path
@@ skipping 56 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