Refactor webkitpy.layout_tests.servers.server_base.

Tools/Scripts/webkitpy/layout_tests/servers/server_base.py

 # Copyright (C) 2011 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
 # in the documentation and/or other materials provided with the
 # distribution.
 #     * Neither the name of Google Inc. nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-"""Base class with common routines between the Apache, Lighttpd, and websocket servers."""
+"""Base class used to start servers used by the layout tests."""
 
 import errno
 import logging
 import socket
 import sys
 import tempfile
 import time
 
 
 _log = logging.getLogger(__name__)
 
 
 class ServerError(Exception):
     pass
 
 
 class ServerBase(object):
     """A skeleton class for starting and stopping servers used by the layout tests."""
 
-    def __init__(self, port_obj, number_of_servers=None):
+    def __init__(self, port_obj, output_dir):
+        self._port_obj = port_obj
         self._executive = port_obj._executive
         self._filesystem = port_obj._filesystem
-        self._name = '<virtual>'
-        self._mappings = {}
-        self._pid = None
-        self._pid_file = None
-        self._port_obj = port_obj
-        self._number_of_servers = number_of_servers
+        self._output_dir = output_dir
 
         # We need a non-checkout-dependent place to put lock files, etc. We
         # don't use the Python default on the Mac because it defaults to a
         # randomly-generated directory under /var/folders and no one would ever
         # look there.
         tmpdir = tempfile.gettempdir()
         if port_obj.host.platform.is_mac():
             tmpdir = '/tmp'
 
         self._runtime_path = self._filesystem.join(tmpdir, "WebKit")
         self._filesystem.maybe_make_directory(self._runtime_path)
 
+        # Subclasses must override these fields.
+        self._name = '<virtual>'
+        self._log_prefixes = tuple()
+        self._mappings = {}
+        self._pid_file = None
+        self._start_cmd = None
+
+        # Subclasses may override these fields.
+        self._env = None
+        self._stdout = self._executive.PIPE
+        self._stderr = self._executive.PIPE
+        self._process = None
+        self._pid = None
+
     def start(self):
         """Starts the server. It is an error to start an already started server.
 
         This method also stops any stale servers started by a previous instance."""
         assert not self._pid, '%s server is already running' % self._name
 
         # Stop any stale servers left over from previous instances.
         if self._filesystem.exists(self._pid_file):
             try:
                 self._pid = int(self._filesystem.read_text_file(self._pid_file))
@@ skipping 53 matching lines @@
     def _prepare_config(self):
         """This routine can be overridden by subclasses to do any sort
         of initialization required prior to starting the server that may fail."""
         pass
 
     def _remove_stale_logs(self):
         """This routine can be overridden by subclasses to try and remove logs
         left over from a prior run. This routine should log warnings if the
         files cannot be deleted, but should not fail unless failure to
         delete the logs will actually cause start() to fail."""
-        pass
+        # Sometimes logs are open in other processes but they should clear eventually.
+        for log_prefix in self._log_prefixes:
+            try:
+                self._remove_log_files(self._output_dir, log_prefix)
+            except OSError, e:
+                _log.warning('Failed to remove old %s %s files' % (self._name, log_prefix))
 
     def _spawn_process(self):
-        """This routine must be implemented by subclasses to actually start the server.
-
-        This routine returns the pid of the started process, and also ensures that that
-        pid has been written to self._pid_file."""
-        raise NotImplementedError()
+        _log.debug('Starting %s server, cmd="%s"' % (self._name, self._start_cmd))
+        process = self._executive.popen(self._start_cmd, env=self._env, stdout=self._stdout, stderr=self._stderr)
+        pid = process.pid
+        self._filesystem.write_text_file(self._pid_file, str(pid))
+        return pid
 
     def _stop_running_server(self):
-        """This routine must be implemented by subclasses to actually stop the running server listed in self._pid_file."""
-        raise NotImplementedError()
+        self._wait_for_action(self._check_and_kill)
+        if self._filesystem.exists(self._pid_file):
+            self._filesystem.remove(self._pid_file)
 
-    # Utility routines.
+    def _check_and_kill(self):
+        if self._executive.check_running_pid(self._pid):
+            host = self._port_obj.host
+            self._executive.kill_process(self._pid)
+            return False
+        return True
 
     def _remove_pid_file(self):
         if self._filesystem.exists(self._pid_file):
             self._filesystem.remove(self._pid_file)
 
     def _remove_log_files(self, folder, starts_with):
         files = self._filesystem.listdir(folder)
         for file in files:
             if file.startswith(starts_with):
                 full_path = self._filesystem.join(folder, file)
@@ skipping 41 matching lines @@
                 s.bind(('localhost', port))
             except IOError, e:
                 if e.errno in (errno.EALREADY, errno.EADDRINUSE):
                     raise ServerError('Port %d is already in use.' % port)
                 elif sys.platform == 'win32' and e.errno in (errno.WSAEACCES,):  # pylint: disable=E1101
                     raise ServerError('Port %d is already in use.' % port)
                 else:
                     raise
             finally:
                 s.close()