Tools/ChangeLog

112011-06-13 Dirk Pranke <dpranke@chromium.org>

22

        Reviewed by NOBODY (OOPS!).

        nrwt: should clean up stale server processes from a previous run

        https://bugs.webkit.org/show_bug.cgi?id=62615

        This change fixes cases where NRWT might start a server and then

        exit, leaving the server still running. Now NRWT should detect

        this case and clean up on the next run, without shutting down

        any processes it didn't start.

        This change also fixes a bug in executive.kill_process on UNIX

        where zombies weren't being handled properly.

        * Scripts/webkitpy/common/system/executive.py:

        * Scripts/webkitpy/layout_tests/port/apache_http_server.py:

        * Scripts/webkitpy/layout_tests/port/base.py:

        * Scripts/webkitpy/layout_tests/port/http_server.py:

        * Scripts/webkitpy/layout_tests/port/http_server_base.py:

        * Scripts/webkitpy/layout_tests/port/port_testcase.py:

        * Scripts/webkitpy/layout_tests/port/websocket_server.py:

2011-06-13  Dirk Pranke  <dpranke@chromium.org>

        Reviewed by Tony Chang.

        nrwt: fix http, websocket server startup, shutdown

Tools/Scripts/webkitpy/common/system/executive.py

@@class Executive(object):

            try:

                retries_left -= 1

                os.kill(pid, signal.SIGKILL)

230 _ = os.waitpid(pid, os.WNOHANG)

            except OSError, e:

                if e.errno == errno.EAGAIN:

                    if retries_left <= 0:

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

@@class LayoutTestApacheHttpd(http_server_base.HttpServerBase):

        self._name = 'apache'

        port_obj.maybe_make_directory(output_dir)

        # The upstream .conf file assumed the existence of /tmp/WebKit for

        # placing apache files like the lock file there.

        self._runtime_path = os.path.join("/tmp", "WebKit")

        port_obj.maybe_make_directory(self._runtime_path)

        # The PID returned when Apache is started goes away (due to dropping

        # privileges?). The proper controlling PID is written to a file in the

        # apache runtime directory.

68 self.pid_file = os~~.pa~~th.join(self._runtime_path, '~~httpd~~.pid')

63 self._pid_file = self._filesystem.join(self._runtime_path, '%s.pid' % self._name)

        test_dir = self._port_obj.layout_tests_dir()

        js_test_resources_dir = self._cygwin_safe_join(test_dir, "fast", "js",

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

@@class Port(object):

        """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."""

647 assert not self._http_server, 'Already running an http server.'

648

        if self.get_option('use_apache'):

            server = apache_http_server.LayoutTestApacheHttpd(self, self.results_directory())

        else:

            server = http_server.Lighttpd(self, self.results_directory())

653

        server.start()

        self._http_server = server

@@class Port(object):

        """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."""

661 assert not self._websocket_server, 'Already running a websocket server.'

662

        server = websocket_server.PyWebSocket(self, self.results_directory())

        server.start()

        self._websocket_server = server

@@class Port(object):

        """Shut down the http server if it is running. Do nothing if it isn't."""

        if self._http_server:

            self._http_server.stop()

681 self._http_server = None

    def stop_websocket_server(self):

        """Shut down the websocket server if it is running. Do nothing if it isn't."""

        if self._websocket_server:

            self._websocket_server.stop()

687 self._websocket_server = None

    def release_http_lock(self):

        if self._http_lock:

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

@@class Lighttpd(http_server_base.HttpServerBase):

        self._run_background = run_background

        self._layout_tests_dir = layout_tests_dir

57 self._pid_file = self._filesystem.join(self._runtime_path, '%s.pid' % self._name)

58

        if self._port:

            self._port = int(self._port)

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

import errno

import logging

import socket

35import sys

36import tempfile

import time

_log = logging.getLogger("webkitpy.layout_tests.port.http_server_base")

@@class HttpServerBase(object):

        self._port_obj = port_obj

        self._process = None

        # 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 sys.platform == 'darwin':

            tmpdir = '/tmp'

        self._runtime_path = self._filesystem.join(tmpdir, "WebKit")

        port_obj.maybe_make_directory(self._runtime_path)

5669 def start(self):

5770 """Starts the server."""

58 if self._process:

59 raise ServerError('%s already running' % self._name)

71 assert not self._process, '%s server is already running.'

6072

73 self._remove_stale_processes()

        self._remove_stale_logs()

        self._prepare_config()

        self._check_that_all_ports_are_available()

@@class HttpServerBase(object):

        of initialization required prior to starting the server that may fail."""

        pass

    def _remove_stale_processes(self):

        """Remove any instances of the server left over from a previous run.

        There should be at most one of these because of the global http lock."""

        def kill_and_check(name, pid):

            _log.warning('Previously started %s is still running as pid %d, trying to kill it.' % (name, pid))

            self._executive.kill_process(pid)

            return not self._executive.check_running_pid(pid)

        if self._pid_file and self._filesystem.exists(self._pid_file):

            pid = int(self._filesystem.read_text_file(self._pid_file))

            if not self._executive.check_running_pid(pid) or self._wait_for_action(lambda: kill_and_check(self._name, pid)):

                self._filesystem.remove(self._pid_file)

    def _remove_stale_logs(self):

        """This routine should be implemented by subclasses to try and remove logs

        left over from a prior run. This routine should log warnings if the

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

@@class PortTestCase(unittest.TestCase):

        # Test that calling start() twice fails.

        try:

            port.start_http_server()

            try:

                port.start_http_server()

                self.fail('calling port.start_http_server() twice worked')

            except http_server_base.ServerError, e:

                pass

171 self.assertRaises(AssertionError, port.start_http_server)

        finally:

            port.stop_http_server()

        # Test that calling start() once, then resetting the port state, then

        # calling start() again so that there is a dangling process that is

        # cleaned up works.

        try:

            port.start_http_server()

            port._http_server = None

            port.start_http_server()

        finally:

            port.stop_websocket_server()

        # Test that calling stop() twice is harmless.

        port.stop_http_server()

@@class PortTestCase(unittest.TestCase):

        # Test that calling start() twice fails.

        try:

            port.start_websocket_server()

            try:

                port.start_websocket_server()

                self.fail('calling port.start_websocket_server() twice worked')

            except http_server_base.ServerError, e:

                pass

            self.assertRaises(AssertionError, port.start_websocket_server)

        finally:

            port.stop_websocket_server()

        # Test that calling start() once, then resetting the port state, then

        # calling start() again so that there is a dangling process that is

        # cleaned up works.

        try:

            port.start_websocket_server()

            port._websocket_server = None

            port.start_websocket_server()

        finally:

            port.stop_websocket_server()

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

@@class PyWebSocket(http_server.Lighttpd):

        self._wsout = None

        self._mappings = [{'port': self._port}]

        if not self._pid_file:

            self._pid_file = self._filesystem.join(self._runtime_path, '%s.pid' % self._name)

        # Webkit tests

        if self._root:

            self._layout_tests = os.path.abspath(self._root)