[android] Upstream / sync most of build/android and build/android/pylib.

build/android/lighttpd_server.py

 #!/usr/bin/env python
-# Copyright (c) 2011 The Chromium Authors. All rights reserved.
+#
+# Copyright (c) 2012 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.
 
 """Provides a convenient wrapper for spawning a test lighttpd instance.
 
 Usage:
   lighttpd_server PATH_TO_DOC_ROOT
 """
 
 import codecs
 import contextlib
 import httplib
 import os
 import pexpect
 import random
 import shutil
 import socket
+import subprocess
 import sys
 import tempfile
+import time
+
+from pylib import constants
 
 
 class LighttpdServer(object):
   """Wraps lighttpd server, providing robust startup.
 
   Args:
     document_root: Path to root of this server's hosted files.
     port: TCP port on the _host_ machine that the server will listen on. If
         ommitted it will attempt to use 9000, or if unavailable it will find
         a free port from 8001 - 8999.
     lighttpd_path, lighttpd_module_path: Optional paths to lighttpd binaries.
     base_config_path: If supplied this file will replace the built-in default
         lighttpd config file.
     extra_config_contents: If specified, this string will be appended to the
         base config (default built-in, or from base_config_path).
     config_path, error_log, access_log: Optional paths where the class should
         place temprary files for this session.
   """
 
   def __init__(self, document_root, port=None,
                lighttpd_path=None, lighttpd_module_path=None,
                base_config_path=None, extra_config_contents=None,
                config_path=None, error_log=None, access_log=None):
     self.temp_dir = tempfile.mkdtemp(prefix='lighttpd_for_chrome_android')
     self.document_root = os.path.abspath(document_root)
     self.fixed_port = port
-    self.port = port or 9000
+    self.port = port or constants.LIGHTTPD_DEFAULT_PORT
     self.server_tag = 'LightTPD ' + str(random.randint(111111, 999999))
     self.lighttpd_path = lighttpd_path or '/usr/sbin/lighttpd'
     self.lighttpd_module_path = lighttpd_module_path or '/usr/lib/lighttpd'
     self.base_config_path = base_config_path
     self.extra_config_contents = extra_config_contents
     self.config_path = config_path or self._Mktmp('config')
     self.error_log = error_log or self._Mktmp('error_log')
     self.access_log = access_log or self._Mktmp('access_log')
     self.pid_file = self._Mktmp('pid_file')
     self.process = None
 
   def _Mktmp(self, name):
     return os.path.join(self.temp_dir, name)
 
   def _GetRandomPort(self):
-    # Ports 8001-8004 are reserved for other test servers. Ensure we don't
-    # collide with them.
-    return random.randint(8005, 8999)
+    # The ports of test server is arranged in constants.py.
+    return random.randint(constants.LIGHTTPD_RANDOM_PORT_FIRST,
+                          constants.LIGHTTPD_RANDOM_PORT_LAST)
 
   def StartupHttpServer(self):
     """Starts up a http server with specified document root and port."""
-    # Currently we use lighttpd as http sever in test.
+    # If we want a specific port, make sure no one else is listening on it.
+    if self.fixed_port:
+      self._KillProcessListeningOnPort(self.fixed_port)
     while True:
       if self.base_config_path:
         # Read the config
         with codecs.open(self.base_config_path, 'r', 'utf-8') as f:
           config_contents = f.read()
       else:
         config_contents = self._GetDefaultBaseConfig()
       if self.extra_config_contents:
         config_contents += self.extra_config_contents
       # Write out the config, filling in placeholders from the members of |self|
@@ skipping 51 matching lines @@
       # Check for server startup error messages
       ix = self.process.expect([pexpect.TIMEOUT, pexpect.EOF, '.+'],
                                timeout=timeout)
       if ix == 2:  # stdout spew from the server
         server_msg += self.process.match.group(0)
       elif ix == 1:  # EOF -- server has quit so giveup.
         client_error = client_error or 'Server exited'
         break
     return (client_error or 'Timeout', server_msg)
 
+  def _KillProcessListeningOnPort(self, port):
+    """Checks if there is a process listening on port number |port| and
+    terminates it if found.
+
+    Args:
+      port: Port number to check.
+    """
+    if subprocess.call(['fuser', '-kv', '%d/tcp' % port]) == 0:
+      # Give the process some time to terminate and check that it is gone.
+      time.sleep(2)
+      assert subprocess.call(['fuser', '-v', '%d/tcp' % port]) != 0, \
+          'Unable to kill process listening on port %d.' % port
+
   def _GetDefaultBaseConfig(self):
     return """server.tag                  = "%(server_tag)s"
 server.modules              = ( "mod_access",
                                 "mod_accesslog",
                                 "mod_alias",
                                 "mod_cgi",
                                 "mod_rewrite" )
 
 # default document root required
 #server.document-root = "."
@@ skipping 73 matching lines @@
       raw_input('Server running at http://127.0.0.1:%s -'
                 ' press Enter to exit it.' % server.port)
     else:
       print 'Server exit code:', server.process.exitstatus
   finally:
     server.ShutdownHttpServer()
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))