cf4f4a26cff238cd11668438ee5dbbb9e8ff69ad
[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             return self._proc.poll()
108         return None
109
110     def returncode(self):
111         """Returns the exit code from the subprcoess; returns None if the
112         process hasn't exited (this is a wrapper around subprocess.returncode).
113         """
114         if self._proc:
115             return self._proc.returncode
116         return None
117
118     def write(self, input):
119         """Write a request to the subprocess. The subprocess is (re-)start()'ed
120         if is not already running."""
121         if not self._proc:
122             self._start()
123         self._proc.stdin.write(input)
124
125     def read_line(self, timeout):
126         """Read a single line from the subprocess, waiting until the deadline.
127         If the deadline passes, the call times out. Note that even if the
128         subprocess has crashed or the deadline has passed, if there is output
129         pending, it will be returned.
130
131         Args:
132             timeout: floating-point number of seconds the call is allowed
133                 to block for. A zero or negative number will attempt to read
134                 any existing data, but will not block. There is no way to
135                 block indefinitely.
136         Returns:
137             output: data returned, if any. If no data is available and the
138                 call times out or crashes, an empty string is returned. Note
139                 that the returned string includes the newline ('\n')."""
140         return self._read(timeout, size=0)
141
142     def read(self, timeout, size):
143         """Attempts to read size characters from the subprocess, waiting until
144         the deadline passes. If the deadline passes, any available data will be
145         returned. Note that even if the deadline has passed or if the
146         subprocess has crashed, any available data will still be returned.
147
148         Args:
149             timeout: floating-point number of seconds the call is allowed
150                 to block for. A zero or negative number will attempt to read
151                 any existing data, but will not block. There is no way to
152                 block indefinitely.
153             size: amount of data to read. Must be a postive integer.
154         Returns:
155             output: data returned, if any. If no data is available, an empty
156                 string is returned.
157         """
158         if size <= 0:
159             raise ValueError('ServerProcess.read() called with a '
160                              'non-positive size: %d ' % size)
161         return self._read(timeout, size)
162
163     def _read(self, timeout, size):
164         """Internal routine that actually does the read."""
165         index = -1
166         out_fd = self._proc.stdout.fileno()
167         err_fd = self._proc.stderr.fileno()
168         select_fds = (out_fd, err_fd)
169         deadline = time.time() + timeout
170         while not self.timed_out and not self.crashed:
171             if self._proc.poll() != None:
172                 self.crashed = True
173                 self.handle_interrupt()
174
175             now = time.time()
176             if now > deadline:
177                 self.timed_out = True
178
179             # Check to see if we have any output we can return.
180             if size and len(self._output) >= size:
181                 index = size
182             elif size == 0:
183                 index = self._output.find('\n') + 1
184
185             if index or self.crashed or self.timed_out:
186                 output = self._output[0:index]
187                 self._output = self._output[index:]
188                 return output
189
190             # Nope - wait for more data.
191             (read_fds, write_fds, err_fds) = select.select(select_fds, [],
192                                                            select_fds,
193                                                            deadline - now)
194             try:
195                 if out_fd in read_fds:
196                     self._output += self._proc.stdout.read()
197                 if err_fd in read_fds:
198                     self.error += self._proc.stderr.read()
199             except IOError, e:
200                 pass
201
202     def stop(self):
203         """Stop (shut down) the subprocess), if it is running."""
204         pid = self._proc.pid
205         self._proc.stdin.close()
206         self._proc.stdout.close()
207         if self._proc.stderr:
208             self._proc.stderr.close()
209         if sys.platform not in ('win32', 'cygwin'):
210             # Closing stdin/stdout/stderr hangs sometimes on OS X,
211             # (see restart(), above), and anyway we don't want to hang
212             # the harness if DumpRenderTree is buggy, so we wait a couple
213             # seconds to give DumpRenderTree a chance to clean up, but then
214             # force-kill the process if necessary.
215             KILL_TIMEOUT = 3.0
216             timeout = time.time() + KILL_TIMEOUT
217             while self._proc.poll() is None and time.time() < timeout:
218                 time.sleep(0.1)
219             if self._proc.poll() is None:
220                 _log.warning('stopping %s timed out, killing it' %
221                              self._name)
222                 self._executive.kill_process(self._proc.pid)
223                 _log.warning('killed')
224         self._reset()