62ca69312ab07ae3ab59ff3e5c94b6752538debb
[WebKit-https.git] / WebKitTools / 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 fcntl
33 import logging
34 import os
35 import select
36 import signal
37 import subprocess
38 import sys
39 import time
40
41 from webkitpy.common.system.executive import Executive
42
43 _log = logging.getLogger("webkitpy.layout_tests.port.server_process")
44
45
46 class ServerProcess:
47     """This class provides a wrapper around a subprocess that
48     implements a simple request/response usage model. The primary benefit
49     is that reading responses takes a timeout, so that we don't ever block
50     indefinitely. The class also handles transparently restarting processes
51     as necessary to keep issuing commands."""
52
53     def __init__(self, port_obj, name, cmd, env=None, executive=Executive()):
54         self._port = port_obj
55         self._name = name
56         self._cmd = cmd
57         self._env = env
58         self._reset()
59         self._executive = executive
60
61     def _reset(self):
62         self._proc = None
63         self._output = ''
64         self.crashed = False
65         self.timed_out = False
66         self.error = ''
67
68     def _start(self):
69         if self._proc:
70             raise ValueError("%s already running" % self._name)
71         self._reset()
72         # close_fds is a workaround for http://bugs.python.org/issue2320
73         close_fds = sys.platform not in ('win32', 'cygwin')
74         self._proc = subprocess.Popen(self._cmd, stdin=subprocess.PIPE,
75                                       stdout=subprocess.PIPE,
76                                       stderr=subprocess.PIPE,
77                                       close_fds=close_fds,
78                                       env=self._env)
79         fd = self._proc.stdout.fileno()
80         fl = fcntl.fcntl(fd, fcntl.F_GETFL)
81         fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
82         fd = self._proc.stderr.fileno()
83         fl = fcntl.fcntl(fd, fcntl.F_GETFL)
84         fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
85
86     def handle_interrupt(self):
87         """This routine checks to see if the process crashed or exited
88         because of a keyboard interrupt and raises KeyboardInterrupt
89         accordingly."""
90         if self.crashed:
91             # This is hex code 0xc000001d, which is used for abrupt
92             # termination. This happens if we hit ctrl+c from the prompt
93             # and we happen to be waiting on the DumpRenderTree.
94             # sdoyon: Not sure for which OS and in what circumstances the
95             # above code is valid. What works for me under Linux to detect
96             # ctrl+c is for the subprocess returncode to be negative
97             # SIGINT. And that agrees with the subprocess documentation.
98             if (-1073741510 == self._proc.returncode or
99                 - signal.SIGINT == self._proc.returncode):
100                 raise KeyboardInterrupt
101             return
102
103     def poll(self):
104         """Check to see if the underlying process is running; returns None
105         if it still is (wrapper around subprocess.poll)."""
106         if self._proc:
107             # poll() is not threadsafe and can throw OSError due to:
108             # http://bugs.python.org/issue1731717
109             return self._proc.poll()
110         return None
111
112     def returncode(self):
113         """Returns the exit code from the subprcoess; returns None if the
114         process hasn't exited (this is a wrapper around subprocess.returncode).
115         """
116         if self._proc:
117             return self._proc.returncode
118         return None
119
120     def write(self, input):
121         """Write a request to the subprocess. The subprocess is (re-)start()'ed
122         if is not already running."""
123         if not self._proc:
124             self._start()
125         self._proc.stdin.write(input)
126
127     def read_line(self, timeout):
128         """Read a single line from the subprocess, waiting until the deadline.
129         If the deadline passes, the call times out. Note that even if the
130         subprocess has crashed or the deadline has passed, if there is output
131         pending, it will be returned.
132
133         Args:
134             timeout: floating-point number of seconds the call is allowed
135                 to block for. A zero or negative number will attempt to read
136                 any existing data, but will not block. There is no way to
137                 block indefinitely.
138         Returns:
139             output: data returned, if any. If no data is available and the
140                 call times out or crashes, an empty string is returned. Note
141                 that the returned string includes the newline ('\n')."""
142         return self._read(timeout, size=0)
143
144     def read(self, timeout, size):
145         """Attempts to read size characters from the subprocess, waiting until
146         the deadline passes. If the deadline passes, any available data will be
147         returned. Note that even if the deadline has passed or if the
148         subprocess has crashed, any available data will still be returned.
149
150         Args:
151             timeout: floating-point number of seconds the call is allowed
152                 to block for. A zero or negative number will attempt to read
153                 any existing data, but will not block. There is no way to
154                 block indefinitely.
155             size: amount of data to read. Must be a postive integer.
156         Returns:
157             output: data returned, if any. If no data is available, an empty
158                 string is returned.
159         """
160         if size <= 0:
161             raise ValueError('ServerProcess.read() called with a '
162                              'non-positive size: %d ' % size)
163         return self._read(timeout, size)
164
165     def _read(self, timeout, size):
166         """Internal routine that actually does the read."""
167         index = -1
168         out_fd = self._proc.stdout.fileno()
169         err_fd = self._proc.stderr.fileno()
170         select_fds = (out_fd, err_fd)
171         deadline = time.time() + timeout
172         while not self.timed_out and not self.crashed:
173             # poll() is not threadsafe and can throw OSError due to:
174             # http://bugs.python.org/issue1731717
175             if self._proc.poll() != None:
176                 self.crashed = True
177                 self.handle_interrupt()
178
179             now = time.time()
180             if now > deadline:
181                 self.timed_out = True
182
183             # Check to see if we have any output we can return.
184             if size and len(self._output) >= size:
185                 index = size
186             elif size == 0:
187                 index = self._output.find('\n') + 1
188
189             if index or self.crashed or self.timed_out:
190                 output = self._output[0:index]
191                 self._output = self._output[index:]
192                 return output
193
194             # Nope - wait for more data.
195             (read_fds, write_fds, err_fds) = select.select(select_fds, [],
196                                                            select_fds,
197                                                            deadline - now)
198             try:
199                 if out_fd in read_fds:
200                     self._output += self._proc.stdout.read()
201                 if err_fd in read_fds:
202                     self.error += self._proc.stderr.read()
203             except IOError, e:
204                 pass
205
206     def stop(self):
207         """Stop (shut down) the subprocess), if it is running."""
208         pid = self._proc.pid
209         self._proc.stdin.close()
210         self._proc.stdout.close()
211         if self._proc.stderr:
212             self._proc.stderr.close()
213         if sys.platform not in ('win32', 'cygwin'):
214             # Closing stdin/stdout/stderr hangs sometimes on OS X,
215             # (see restart(), above), and anyway we don't want to hang
216             # the harness if DumpRenderTree is buggy, so we wait a couple
217             # seconds to give DumpRenderTree a chance to clean up, but then
218             # force-kill the process if necessary.
219             KILL_TIMEOUT = 3.0
220             timeout = time.time() + KILL_TIMEOUT
221             # poll() is not threadsafe and can throw OSError due to:
222             # http://bugs.python.org/issue1731717
223             while self._proc.poll() is None and time.time() < timeout:
224                 time.sleep(0.1)
225             # poll() is not threadsafe and can throw OSError due to:
226             # http://bugs.python.org/issue1731717
227             if self._proc.poll() is None:
228                 _log.warning('stopping %s timed out, killing it' %
229                              self._name)
230                 self._executive.kill_process(self._proc.pid)
231                 _log.warning('killed')
232         self._reset()