Rename WebKitTools to Tools
[WebKit-https.git] / Tools / Scripts / webkitpy / layout_tests / port / server_process.py
1 #!/usr/bin/env python
2 # Copyright (C) 2010 Google Inc. All rights reserved.
3 #
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions are
6 # met:
7 #
8 #     * Redistributions of source code must retain the above copyright
9 # notice, this list of conditions and the following disclaimer.
10 #     * Redistributions in binary form must reproduce the above
11 # copyright notice, this list of conditions and the following disclaimer
12 # in the documentation and/or other materials provided with the
13 # distribution.
14 #     * Neither the Google name nor the names of its
15 # contributors may be used to endorse or promote products derived from
16 # this software without specific prior written permission.
17 #
18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 """Package that implements the ServerProcess wrapper class"""
31
32 import logging
33 import os
34 import select
35 import signal
36 import subprocess
37 import sys
38 import time
39 if sys.platform != 'win32':
40     import fcntl
41
42 from webkitpy.common.system.executive import Executive
43
44 _log = logging.getLogger("webkitpy.layout_tests.port.server_process")
45
46
47 class ServerProcess:
48     """This class provides a wrapper around a subprocess that
49     implements a simple request/response usage model. The primary benefit
50     is that reading responses takes a timeout, so that we don't ever block
51     indefinitely. The class also handles transparently restarting processes
52     as necessary to keep issuing commands."""
53
54     def __init__(self, port_obj, name, cmd, env=None, executive=Executive()):
55         self._port = port_obj
56         self._name = name
57         self._cmd = cmd
58         self._env = env
59         self._reset()
60         self._executive = executive
61
62     def _reset(self):
63         self._proc = None
64         self._output = ''
65         self.crashed = False
66         self.timed_out = False
67         self.error = ''
68
69     def _start(self):
70         if self._proc:
71             raise ValueError("%s already running" % self._name)
72         self._reset()
73         # close_fds is a workaround for http://bugs.python.org/issue2320
74         close_fds = sys.platform not in ('win32', 'cygwin')
75         self._proc = subprocess.Popen(self._cmd, stdin=subprocess.PIPE,
76                                       stdout=subprocess.PIPE,
77                                       stderr=subprocess.PIPE,
78                                       close_fds=close_fds,
79                                       env=self._env)
80         fd = self._proc.stdout.fileno()
81         fl = fcntl.fcntl(fd, fcntl.F_GETFL)
82         fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
83         fd = self._proc.stderr.fileno()
84         fl = fcntl.fcntl(fd, fcntl.F_GETFL)
85         fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
86
87     def handle_interrupt(self):
88         """This routine checks to see if the process crashed or exited
89         because of a keyboard interrupt and raises KeyboardInterrupt
90         accordingly."""
91         if self.crashed:
92             # This is hex code 0xc000001d, which is used for abrupt
93             # termination. This happens if we hit ctrl+c from the prompt
94             # and we happen to be waiting on the DumpRenderTree.
95             # sdoyon: Not sure for which OS and in what circumstances the
96             # above code is valid. What works for me under Linux to detect
97             # ctrl+c is for the subprocess returncode to be negative
98             # SIGINT. And that agrees with the subprocess documentation.
99             if (-1073741510 == self._proc.returncode or
100                 - signal.SIGINT == self._proc.returncode):
101                 raise KeyboardInterrupt
102             return
103
104     def poll(self):
105         """Check to see if the underlying process is running; returns None
106         if it still is (wrapper around subprocess.poll)."""
107         if self._proc:
108             # poll() is not threadsafe and can throw OSError due to:
109             # http://bugs.python.org/issue1731717
110             return self._proc.poll()
111         return None
112
113     def write(self, input):
114         """Write a request to the subprocess. The subprocess is (re-)start()'ed
115         if is not already running."""
116         if not self._proc:
117             self._start()
118         self._proc.stdin.write(input)
119
120     def read_line(self, timeout):
121         """Read a single line from the subprocess, waiting until the deadline.
122         If the deadline passes, the call times out. Note that even if the
123         subprocess has crashed or the deadline has passed, if there is output
124         pending, it will be returned.
125
126         Args:
127             timeout: floating-point number of seconds the call is allowed
128                 to block for. A zero or negative number will attempt to read
129                 any existing data, but will not block. There is no way to
130                 block indefinitely.
131         Returns:
132             output: data returned, if any. If no data is available and the
133                 call times out or crashes, an empty string is returned. Note
134                 that the returned string includes the newline ('\n')."""
135         return self._read(timeout, size=0)
136
137     def read(self, timeout, size):
138         """Attempts to read size characters from the subprocess, waiting until
139         the deadline passes. If the deadline passes, any available data will be
140         returned. Note that even if the deadline has passed or if the
141         subprocess has crashed, any available data will still be returned.
142
143         Args:
144             timeout: floating-point number of seconds the call is allowed
145                 to block for. A zero or negative number will attempt to read
146                 any existing data, but will not block. There is no way to
147                 block indefinitely.
148             size: amount of data to read. Must be a postive integer.
149         Returns:
150             output: data returned, if any. If no data is available, an empty
151                 string is returned.
152         """
153         if size <= 0:
154             raise ValueError('ServerProcess.read() called with a '
155                              'non-positive size: %d ' % size)
156         return self._read(timeout, size)
157
158     def _read(self, timeout, size):
159         """Internal routine that actually does the read."""
160         index = -1
161         out_fd = self._proc.stdout.fileno()
162         err_fd = self._proc.stderr.fileno()
163         select_fds = (out_fd, err_fd)
164         deadline = time.time() + timeout
165         while not self.timed_out and not self.crashed:
166             # poll() is not threadsafe and can throw OSError due to:
167             # http://bugs.python.org/issue1731717
168             if self._proc.poll() != None:
169                 self.crashed = True
170                 self.handle_interrupt()
171
172             now = time.time()
173             if now > deadline:
174                 self.timed_out = True
175
176             # Check to see if we have any output we can return.
177             if size and len(self._output) >= size:
178                 index = size
179             elif size == 0:
180                 index = self._output.find('\n') + 1
181
182             if index > 0 or self.crashed or self.timed_out:
183                 output = self._output[0:index]
184                 self._output = self._output[index:]
185                 return output
186
187             # Nope - wait for more data.
188             (read_fds, write_fds, err_fds) = select.select(select_fds, [],
189                                                            select_fds,
190                                                            deadline - now)
191             try:
192                 if out_fd in read_fds:
193                     self._output += self._proc.stdout.read()
194                 if err_fd in read_fds:
195                     self.error += self._proc.stderr.read()
196             except IOError, e:
197                 pass
198
199     def stop(self):
200         """Stop (shut down) the subprocess), if it is running."""
201         pid = self._proc.pid
202         self._proc.stdin.close()
203         self._proc.stdout.close()
204         if self._proc.stderr:
205             self._proc.stderr.close()
206         if sys.platform not in ('win32', 'cygwin'):
207             # Closing stdin/stdout/stderr hangs sometimes on OS X,
208             # (see restart(), above), and anyway we don't want to hang
209             # the harness if DumpRenderTree is buggy, so we wait a couple
210             # seconds to give DumpRenderTree a chance to clean up, but then
211             # force-kill the process if necessary.
212             KILL_TIMEOUT = 3.0
213             timeout = time.time() + KILL_TIMEOUT
214             # poll() is not threadsafe and can throw OSError due to:
215             # http://bugs.python.org/issue1731717
216             while self._proc.poll() is None and time.time() < timeout:
217                 time.sleep(0.1)
218             # poll() is not threadsafe and can throw OSError due to:
219             # http://bugs.python.org/issue1731717
220             if self._proc.poll() is None:
221                 _log.warning('stopping %s timed out, killing it' %
222                              self._name)
223                 self._executive.kill_process(self._proc.pid)
224                 _log.warning('killed')
225         self._reset()