checkpoint Blink-side work to use Apache on Windows

Tools/Scripts/webkitpy/layout_tests/port/base.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 44 matching lines @@
 from webkitpy.common.system.path import cygpath
 from webkitpy.common.system.systemhost import SystemHost
 from webkitpy.common.webkit_finder import WebKitFinder
 from webkitpy.layout_tests.layout_package.bot_test_expectations import BotTestExpectationsFactory
 from webkitpy.layout_tests.models import test_run_results
 from webkitpy.layout_tests.models.test_configuration import TestConfiguration
 from webkitpy.layout_tests.port import config as port_config
 from webkitpy.layout_tests.port import driver
 from webkitpy.layout_tests.port import server_process
 from webkitpy.layout_tests.port.factory import PortFactory
-from webkitpy.layout_tests.servers import apache_http_server
-from webkitpy.layout_tests.servers import http_server
-from webkitpy.layout_tests.servers import websocket_server
+from webkitpy.layout_tests.servers import apache_http
+from webkitpy.layout_tests.servers import lighttpd
+from webkitpy.layout_tests.servers import pywebsocket
 
 _log = logging.getLogger(__name__)
 
 
 # FIXME: This class should merge with WebKitPort now that Chromium behaves mostly like other webkit ports.
 class Port(object):
     """Abstract class for Port-specific hooks for the layout_test package."""
 
     # Subclasses override this. This should indicate the basic implementation
     # part of the port name, e.g., 'mac', 'win', 'gtk'; there is probably (?)
@@ skipping 263 matching lines @@
             result = self.check_image_diff(
                 'To override, invoke with --no-pixel-tests') and result
 
         # It's okay if pretty patch and wdiff aren't available, but we will at least log messages.
         self._pretty_patch_available = self.check_pretty_patch()
         self._wdiff_available = self.check_wdiff()
 
         if self._dump_reader:
             result = self._dump_reader.check_is_functional() and result
 
+        if needs_http:
+            result = self.check_httpd() and result
+
         return test_run_results.OK_EXIT_STATUS if result else test_run_results.UNEXPECTED_ERROR_EXIT_STATUS
 
     def _check_driver(self):
         driver_path = self._path_to_driver()
         if not self._filesystem.exists(driver_path):
             _log.error("%s was not found at %s" % (self.driver_name(), driver_path))
             return False
         return True
 
     def _check_port_build(self):
@@ skipping 64 matching lines @@
                         _log.warning('    ' + line)
                         _log.warning('')
             return False
 
         return True
 
     def _wdiff_missing_message(self):
         return 'wdiff is not installed; please install it to generate word-by-word diffs.'
 
     def check_httpd(self):
-        if self._uses_apache():
-            httpd_path = self._path_to_apache()
+        if self.uses_apache():
+            httpd_path = self.path_to_apache()
         else:
-            httpd_path = self._path_to_lighttpd()
+            httpd_path = self.path_to_lighttpd()
 
         try:
             server_name = self._filesystem.basename(httpd_path)
             env = self.setup_environ_for_server(server_name)
             if self._executive.run_command([httpd_path, "-v"], env=env, return_exit_code=True) != 0:
                 _log.error("httpd seems broken. Cannot run http tests.")
                 return False
             return True
         except OSError:
             _log.error("No httpd found. Cannot run http tests.")
@@ skipping 635 matching lines @@
                 stdin=self._executive.PIPE, stdout=self._executive.PIPE, stderr=None)
             is_ready = self._helper.stdout.readline()
             if not is_ready.startswith('ready'):
                 _log.error("layout_test_helper failed to be ready")
 
     def requires_http_server(self):
         """Does the port require an HTTP server for running tests? This could
         be the case when the tests aren't run on the host platform."""
         return False
 
-    def start_http_server(self, additional_dirs=None, number_of_servers=None):
+    def start_http_server(self, number_of_drivers):
         """Start a web server. Raise an error if it can't start or is already running.
 
         Ports can stub this out if they don't need a web server to be running."""
         assert not self._http_server, 'Already running an http server.'
 
-        if self._uses_apache():
-            server = apache_http_server.LayoutTestApacheHttpd(self, self.results_directory(), additional_dirs=additional_dirs, number_of_servers=number_of_servers)
+        if self.uses_apache():
+            server = apache_http.ApacheHttpd(self, self.results_directory(), number_of_drivers * 4)
         else:
-            server = http_server.Lighttpd(self, self.results_directory(), additional_dirs=additional_dirs, number_of_servers=number_of_servers)
+            server = lighttpd.Lighttpd(self, self.results_directory())
 
         server.start()
         self._http_server = server
 
     def start_websocket_server(self):
         """Start a web server. Raise an error if it can't start or is already running.
 
         Ports can stub this out if they don't need a websocket server to be running."""
         assert not self._websocket_server, 'Already running a websocket server.'
 
-        server = websocket_server.PyWebSocket(self, self.results_directory())
+        server = pywebsocket.PyWebSocket(self, self.results_directory())
         server.start()
         self._websocket_server = server
 
     def http_server_supports_ipv6(self):
-        # Cygwin is the only platform to still use Apache 1.3, which only supports IPV4.
-        # Once it moves to Apache 2, we can drop this method altogether.
-        if self.host.platform.is_cygwin():
+        # Apache < 2.4 on win32 does not support IPv6.
+        if self.host.platform.is_cygwin() or self.get_option('use_apache') and self.host.platform.is_win():
             return False
         return True
 
     def stop_helper(self):
         """Shut down the test helper if it is running. Do nothing if
         it isn't, or it isn't available. If a port overrides start_helper()
         it must override this routine as well."""
         if self._helper:
             _log.debug("Stopping layout test helper")
             try:
@@ skipping 228 matching lines @@
             self._pretty_patch_available = False
             _log.error("Failed to run PrettyPatch (%s):\n%s" % (command, e.message_with_output()))
             return self._pretty_patch_error_html
 
     def default_configuration(self):
         return self._config.default_configuration()
 
     def clobber_old_port_specific_results(self):
         pass
 
+    def uses_apache(self):
+        return True
+
+    # FIXME: This does not belong on the port object.
+    @memoized
+    def path_to_apache(self):
+        """Returns the full path to the apache binary.
+
+        This is needed only by ports that use the apache_http_server module."""
+        raise NotImplementedError('Port.path_to_apache')
+
+    def path_to_apache_config_file(self):
+        """Returns the full path to the apache configuration file.
+
+        If the WEBKIT_HTTP_SERVER_CONF_PATH environment variable is set, its
+        contents will be used instead.
+
+        This is needed only by ports that use the apache_http_server module."""
+        config_file_from_env = os.environ.get('WEBKIT_HTTP_SERVER_CONF_PATH')
+        if config_file_from_env:
+            if not self._filesystem.exists(config_file_from_env):
+                raise IOError('%s was not found on the system' % config_file_from_env)
+            return config_file_from_env
+
+        config_file_name = self._apache_config_file_name_for_platform(sys.platform)
+        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', config_file_name)
+
+    def path_to_lighttpd(self):
+        """Returns the path to the LigHTTPd binary.
+
+        This is needed only by ports that use the http_server.py module."""
+        raise NotImplementedError('Port._path_to_lighttpd')
+
+    def path_to_lighttpd_modules(self):
+        """Returns the path to the LigHTTPd modules directory.
+
+        This is needed only by ports that use the http_server.py module."""
+        raise NotImplementedError('Port._path_to_lighttpd_modules')
+
+    def path_to_lighttpd_php(self):
+        """Returns the path to the LigHTTPd PHP executable.
+
+        This is needed only by ports that use the http_server.py module."""
+        raise NotImplementedError('Port._path_to_lighttpd_php')
+
+
     #
     # PROTECTED ROUTINES
     #
     # The routines below should only be called by routines in this class
     # or any of its subclasses.
     #
 
-    def _uses_apache(self):
-        return True
-
-    # FIXME: This does not belong on the port object.
-    @memoized
-    def _path_to_apache(self):
-        """Returns the full path to the apache binary.
-
-        This is needed only by ports that use the apache_http_server module."""
-        raise NotImplementedError('Port._path_to_apache')
-
     # FIXME: This belongs on some platform abstraction instead of Port.
     def _is_redhat_based(self):
         return self._filesystem.exists('/etc/redhat-release')
 
     def _is_debian_based(self):
         return self._filesystem.exists('/etc/debian_version')
 
     def _apache_version(self):
-        config = self._executive.run_command([self._path_to_apache(), '-v'])
+        config = self._executive.run_command([self.path_to_apache(), '-v'])
         return re.sub(r'(?:.|\n)*Server version: Apache/(\d+\.\d+)(?:.|\n)*', r'\1', config)
 
     # We pass sys_platform into this method to make it easy to unit test.
     def _apache_config_file_name_for_platform(self, sys_platform):
         if sys_platform == 'cygwin':
             return 'cygwin-httpd.conf'  # CYGWIN is the only platform to still use Apache 1.3.
         if sys_platform.startswith('linux'):
             if self._is_redhat_based():
                 return 'fedora-httpd-' + self._apache_version() + '.conf'
             if self._is_debian_based():
                 return 'debian-httpd-' + self._apache_version() + '.conf'
         # All platforms use apache2 except for CYGWIN (and Mac OS X Tiger and prior, which we no longer support).
         return "apache2-httpd.conf"
 
-    def _path_to_apache_config_file(self):
-        """Returns the full path to the apache configuration file.
-
-        If the WEBKIT_HTTP_SERVER_CONF_PATH environment variable is set, its
-        contents will be used instead.
-
-        This is needed only by ports that use the apache_http_server module."""
-        config_file_from_env = os.environ.get('WEBKIT_HTTP_SERVER_CONF_PATH')
-        if config_file_from_env:
-            if not self._filesystem.exists(config_file_from_env):
-                raise IOError('%s was not found on the system' % config_file_from_env)
-            return config_file_from_env
-
-        config_file_name = self._apache_config_file_name_for_platform(sys.platform)
-        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', config_file_name)
-
     def _path_to_driver(self, configuration=None):
         """Returns the full path to the test driver."""
         return self._build_path(self.driver_name())
 
     def _path_to_webcore_library(self):
         """Returns the full path to a built copy of WebCore."""
         return None
 
     def _path_to_helper(self):
         """Returns the full path to the layout_test_helper binary, which
         is used to help configure the system for the test run, or None
         if no helper is needed.
 
         This is likely only used by start/stop_helper()."""
         return None
 
     def _path_to_image_diff(self):
         """Returns the full path to the image_diff binary, or None if it is not available.
 
         This is likely used only by diff_image()"""
         return self._build_path('image_diff')
 
-    def _path_to_lighttpd(self):
-        """Returns the path to the LigHTTPd binary.
-
-        This is needed only by ports that use the http_server.py module."""
-        raise NotImplementedError('Port._path_to_lighttpd')
-
-    def _path_to_lighttpd_modules(self):
-        """Returns the path to the LigHTTPd modules directory.
-
-        This is needed only by ports that use the http_server.py module."""
-        raise NotImplementedError('Port._path_to_lighttpd_modules')
-
-    def _path_to_lighttpd_php(self):
-        """Returns the path to the LigHTTPd PHP executable.
-
-        This is needed only by ports that use the http_server.py module."""
-        raise NotImplementedError('Port._path_to_lighttpd_php')
-
     @memoized
     def _path_to_wdiff(self):
         """Returns the full path to the wdiff binary, or None if it is not available.
 
         This is likely used only by wdiff_text()"""
         for path in ("/usr/bin/wdiff", "/usr/bin/dwdiff"):
             if self._filesystem.exists(path):
                 return path
         return None
 
@@ skipping 270 matching lines @@
             if name.find('/') != -1:
                 _log.error("Virtual test suites names cannot contain /'s: %s" % name)
                 return
             self.name = 'virtual/' + name + '/' + base
         self.base = base
         self.args = args
         self.tests = tests or set()
 
     def __repr__(self):
         return "VirtualTestSuite('%s', '%s', %s)" % (self.name, self.base, self.args)