Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 1 | import errno |
| 2 | import os |
Charles-François Natali | e241ac9 | 2013-09-05 20:46:49 +0200 | [diff] [blame] | 3 | import selectors |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 4 | import signal |
| 5 | import socket |
| 6 | import struct |
| 7 | import sys |
| 8 | import threading |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 9 | import warnings |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 10 | |
| 11 | from . import connection |
| 12 | from . import process |
Davin Potts | 5458647 | 2016-09-09 18:03:10 -0500 | [diff] [blame] | 13 | from .context import reduction |
Pierre Glaser | f22cc69 | 2019-05-10 22:59:08 +0200 | [diff] [blame] | 14 | from . import resource_tracker |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 15 | from . import spawn |
| 16 | from . import util |
| 17 | |
| 18 | __all__ = ['ensure_running', 'get_inherited_fds', 'connect_to_new_process', |
| 19 | 'set_forkserver_preload'] |
| 20 | |
| 21 | # |
| 22 | # |
| 23 | # |
| 24 | |
| 25 | MAXFDS_TO_SEND = 256 |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 26 | SIGNED_STRUCT = struct.Struct('q') # large enough for pid_t |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 27 | |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 28 | # |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 29 | # Forkserver class |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 30 | # |
| 31 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 32 | class ForkServer(object): |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 33 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 34 | def __init__(self): |
| 35 | self._forkserver_address = None |
| 36 | self._forkserver_alive_fd = None |
Antoine Pitrou | fc6b348 | 2017-11-03 13:34:22 +0100 | [diff] [blame] | 37 | self._forkserver_pid = None |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 38 | self._inherited_fds = None |
| 39 | self._lock = threading.Lock() |
| 40 | self._preload_modules = ['__main__'] |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 41 | |
Miss Islington (bot) | 229f6e8 | 2019-07-05 07:35:38 -0700 | [diff] [blame] | 42 | def _stop(self): |
| 43 | # Method used by unit tests to stop the server |
| 44 | with self._lock: |
| 45 | self._stop_unlocked() |
| 46 | |
| 47 | def _stop_unlocked(self): |
| 48 | if self._forkserver_pid is None: |
| 49 | return |
| 50 | |
| 51 | # close the "alive" file descriptor asks the server to stop |
| 52 | os.close(self._forkserver_alive_fd) |
| 53 | self._forkserver_alive_fd = None |
| 54 | |
| 55 | os.waitpid(self._forkserver_pid, 0) |
| 56 | self._forkserver_pid = None |
| 57 | |
| 58 | os.unlink(self._forkserver_address) |
| 59 | self._forkserver_address = None |
| 60 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 61 | def set_forkserver_preload(self, modules_names): |
| 62 | '''Set list of module names to try to load in forkserver process.''' |
| 63 | if not all(type(mod) is str for mod in self._preload_modules): |
| 64 | raise TypeError('module_names must be a list of strings') |
| 65 | self._preload_modules = modules_names |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 66 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 67 | def get_inherited_fds(self): |
| 68 | '''Return list of fds inherited from parent process. |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 69 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 70 | This returns None if the current process was not started by fork |
| 71 | server. |
| 72 | ''' |
| 73 | return self._inherited_fds |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 74 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 75 | def connect_to_new_process(self, fds): |
| 76 | '''Request forkserver to create a child process. |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 77 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 78 | Returns a pair of fds (status_r, data_w). The calling process can read |
| 79 | the child process's pid and (eventually) its returncode from status_r. |
| 80 | The calling process should write to data_w the pickled preparation and |
| 81 | process data. |
| 82 | ''' |
| 83 | self.ensure_running() |
| 84 | if len(fds) + 4 >= MAXFDS_TO_SEND: |
| 85 | raise ValueError('too many fds') |
| 86 | with socket.socket(socket.AF_UNIX) as client: |
| 87 | client.connect(self._forkserver_address) |
| 88 | parent_r, child_w = os.pipe() |
| 89 | child_r, parent_w = os.pipe() |
| 90 | allfds = [child_r, child_w, self._forkserver_alive_fd, |
Pierre Glaser | f22cc69 | 2019-05-10 22:59:08 +0200 | [diff] [blame] | 91 | resource_tracker.getfd()] |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 92 | allfds += fds |
Richard Oudkerk | 0718f70 | 2013-08-22 11:38:55 +0100 | [diff] [blame] | 93 | try: |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 94 | reduction.sendfds(client, allfds) |
| 95 | return parent_r, parent_w |
Richard Oudkerk | 0718f70 | 2013-08-22 11:38:55 +0100 | [diff] [blame] | 96 | except: |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 97 | os.close(parent_r) |
| 98 | os.close(parent_w) |
Richard Oudkerk | 0718f70 | 2013-08-22 11:38:55 +0100 | [diff] [blame] | 99 | raise |
| 100 | finally: |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 101 | os.close(child_r) |
| 102 | os.close(child_w) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 103 | |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 104 | def ensure_running(self): |
| 105 | '''Make sure that a fork server is running. |
| 106 | |
| 107 | This can be called from any process. Note that usually a child |
| 108 | process will just reuse the forkserver started by its parent, so |
| 109 | ensure_running() will do nothing. |
| 110 | ''' |
| 111 | with self._lock: |
Pierre Glaser | f22cc69 | 2019-05-10 22:59:08 +0200 | [diff] [blame] | 112 | resource_tracker.ensure_running() |
Antoine Pitrou | fc6b348 | 2017-11-03 13:34:22 +0100 | [diff] [blame] | 113 | if self._forkserver_pid is not None: |
| 114 | # forkserver was launched before, is it still running? |
| 115 | pid, status = os.waitpid(self._forkserver_pid, os.WNOHANG) |
| 116 | if not pid: |
| 117 | # still alive |
| 118 | return |
| 119 | # dead, launch it again |
| 120 | os.close(self._forkserver_alive_fd) |
| 121 | self._forkserver_address = None |
| 122 | self._forkserver_alive_fd = None |
| 123 | self._forkserver_pid = None |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 124 | |
| 125 | cmd = ('from multiprocessing.forkserver import main; ' + |
| 126 | 'main(%d, %d, %r, **%r)') |
| 127 | |
| 128 | if self._preload_modules: |
| 129 | desired_keys = {'main_path', 'sys_path'} |
| 130 | data = spawn.get_preparation_data('ignore') |
Jon Dufresne | 3972628 | 2017-05-18 07:35:54 -0700 | [diff] [blame] | 131 | data = {x: y for x, y in data.items() if x in desired_keys} |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 132 | else: |
| 133 | data = {} |
| 134 | |
| 135 | with socket.socket(socket.AF_UNIX) as listener: |
| 136 | address = connection.arbitrary_address('AF_UNIX') |
| 137 | listener.bind(address) |
| 138 | os.chmod(address, 0o600) |
Charles-François Natali | 6e20460 | 2014-07-23 19:28:13 +0100 | [diff] [blame] | 139 | listener.listen() |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 140 | |
| 141 | # all client processes own the write end of the "alive" pipe; |
| 142 | # when they all terminate the read end becomes ready. |
| 143 | alive_r, alive_w = os.pipe() |
| 144 | try: |
| 145 | fds_to_pass = [listener.fileno(), alive_r] |
| 146 | cmd %= (listener.fileno(), alive_r, self._preload_modules, |
| 147 | data) |
| 148 | exe = spawn.get_executable() |
| 149 | args = [exe] + util._args_from_interpreter_flags() |
| 150 | args += ['-c', cmd] |
| 151 | pid = util.spawnv_passfds(exe, args, fds_to_pass) |
| 152 | except: |
| 153 | os.close(alive_w) |
| 154 | raise |
| 155 | finally: |
| 156 | os.close(alive_r) |
| 157 | self._forkserver_address = address |
| 158 | self._forkserver_alive_fd = alive_w |
Antoine Pitrou | fc6b348 | 2017-11-03 13:34:22 +0100 | [diff] [blame] | 159 | self._forkserver_pid = pid |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 160 | |
| 161 | # |
| 162 | # |
| 163 | # |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 164 | |
| 165 | def main(listener_fd, alive_r, preload, main_path=None, sys_path=None): |
| 166 | '''Run forkserver.''' |
| 167 | if preload: |
| 168 | if '__main__' in preload and main_path is not None: |
| 169 | process.current_process()._inheriting = True |
| 170 | try: |
| 171 | spawn.import_main_path(main_path) |
| 172 | finally: |
| 173 | del process.current_process()._inheriting |
| 174 | for modname in preload: |
| 175 | try: |
| 176 | __import__(modname) |
| 177 | except ImportError: |
| 178 | pass |
| 179 | |
Victor Stinner | a6d865c | 2016-03-25 09:29:50 +0100 | [diff] [blame] | 180 | util._close_stdin() |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 181 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 182 | sig_r, sig_w = os.pipe() |
Antoine Pitrou | 2b5cc5e | 2017-06-13 09:46:06 +0200 | [diff] [blame] | 183 | os.set_blocking(sig_r, False) |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 184 | os.set_blocking(sig_w, False) |
| 185 | |
| 186 | def sigchld_handler(*_unused): |
Antoine Pitrou | 2b5cc5e | 2017-06-13 09:46:06 +0200 | [diff] [blame] | 187 | # Dummy signal handler, doesn't do anything |
| 188 | pass |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 189 | |
Antoine Pitrou | 6dd4d73 | 2017-05-04 16:44:53 +0200 | [diff] [blame] | 190 | handlers = { |
Antoine Pitrou | fc6b348 | 2017-11-03 13:34:22 +0100 | [diff] [blame] | 191 | # unblocking SIGCHLD allows the wakeup fd to notify our event loop |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 192 | signal.SIGCHLD: sigchld_handler, |
Antoine Pitrou | fc6b348 | 2017-11-03 13:34:22 +0100 | [diff] [blame] | 193 | # protect the process from ^C |
| 194 | signal.SIGINT: signal.SIG_IGN, |
Antoine Pitrou | 6dd4d73 | 2017-05-04 16:44:53 +0200 | [diff] [blame] | 195 | } |
| 196 | old_handlers = {sig: signal.signal(sig, val) |
| 197 | for (sig, val) in handlers.items()} |
| 198 | |
Antoine Pitrou | 2b5cc5e | 2017-06-13 09:46:06 +0200 | [diff] [blame] | 199 | # calling os.write() in the Python signal handler is racy |
| 200 | signal.set_wakeup_fd(sig_w) |
| 201 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 202 | # map child pids to client fds |
| 203 | pid_to_fd = {} |
| 204 | |
Charles-François Natali | e241ac9 | 2013-09-05 20:46:49 +0200 | [diff] [blame] | 205 | with socket.socket(socket.AF_UNIX, fileno=listener_fd) as listener, \ |
| 206 | selectors.DefaultSelector() as selector: |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 207 | _forkserver._forkserver_address = listener.getsockname() |
Charles-François Natali | e241ac9 | 2013-09-05 20:46:49 +0200 | [diff] [blame] | 208 | |
| 209 | selector.register(listener, selectors.EVENT_READ) |
| 210 | selector.register(alive_r, selectors.EVENT_READ) |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 211 | selector.register(sig_r, selectors.EVENT_READ) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 212 | |
| 213 | while True: |
| 214 | try: |
Charles-François Natali | e241ac9 | 2013-09-05 20:46:49 +0200 | [diff] [blame] | 215 | while True: |
| 216 | rfds = [key.fileobj for (key, events) in selector.select()] |
| 217 | if rfds: |
| 218 | break |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 219 | |
| 220 | if alive_r in rfds: |
| 221 | # EOF because no more client processes left |
Allen W. Smith, Ph.D | bd73e72 | 2017-08-29 17:52:18 -0500 | [diff] [blame] | 222 | assert os.read(alive_r, 1) == b'', "Not at EOF?" |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 223 | raise SystemExit |
| 224 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 225 | if sig_r in rfds: |
| 226 | # Got SIGCHLD |
| 227 | os.read(sig_r, 65536) # exhaust |
| 228 | while True: |
| 229 | # Scan for child processes |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 230 | try: |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 231 | pid, sts = os.waitpid(-1, os.WNOHANG) |
| 232 | except ChildProcessError: |
| 233 | break |
| 234 | if pid == 0: |
| 235 | break |
| 236 | child_w = pid_to_fd.pop(pid, None) |
| 237 | if child_w is not None: |
| 238 | if os.WIFSIGNALED(sts): |
| 239 | returncode = -os.WTERMSIG(sts) |
| 240 | else: |
Allen W. Smith, Ph.D | bd73e72 | 2017-08-29 17:52:18 -0500 | [diff] [blame] | 241 | if not os.WIFEXITED(sts): |
| 242 | raise AssertionError( |
| 243 | "Child {0:n} status is {1:n}".format( |
| 244 | pid,sts)) |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 245 | returncode = os.WEXITSTATUS(sts) |
Antoine Pitrou | 13e96cc | 2017-06-24 19:22:23 +0200 | [diff] [blame] | 246 | # Send exit code to client process |
| 247 | try: |
| 248 | write_signed(child_w, returncode) |
| 249 | except BrokenPipeError: |
| 250 | # client vanished |
| 251 | pass |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 252 | os.close(child_w) |
| 253 | else: |
| 254 | # This shouldn't happen really |
| 255 | warnings.warn('forkserver: waitpid returned ' |
| 256 | 'unexpected pid %d' % pid) |
| 257 | |
| 258 | if listener in rfds: |
| 259 | # Incoming fork request |
| 260 | with listener.accept()[0] as s: |
| 261 | # Receive fds from client |
| 262 | fds = reduction.recvfds(s, MAXFDS_TO_SEND + 1) |
Allen W. Smith, Ph.D | bd73e72 | 2017-08-29 17:52:18 -0500 | [diff] [blame] | 263 | if len(fds) > MAXFDS_TO_SEND: |
| 264 | raise RuntimeError( |
| 265 | "Too many ({0:n}) fds to send".format( |
| 266 | len(fds))) |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 267 | child_r, child_w, *fds = fds |
| 268 | s.close() |
| 269 | pid = os.fork() |
| 270 | if pid == 0: |
| 271 | # Child |
| 272 | code = 1 |
| 273 | try: |
| 274 | listener.close() |
Antoine Pitrou | 896145d | 2017-07-22 13:22:54 +0200 | [diff] [blame] | 275 | selector.close() |
| 276 | unused_fds = [alive_r, child_w, sig_r, sig_w] |
| 277 | unused_fds.extend(pid_to_fd.values()) |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 278 | code = _serve_one(child_r, fds, |
Antoine Pitrou | 896145d | 2017-07-22 13:22:54 +0200 | [diff] [blame] | 279 | unused_fds, |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 280 | old_handlers) |
| 281 | except Exception: |
| 282 | sys.excepthook(*sys.exc_info()) |
| 283 | sys.stderr.flush() |
| 284 | finally: |
| 285 | os._exit(code) |
| 286 | else: |
Antoine Pitrou | 13e96cc | 2017-06-24 19:22:23 +0200 | [diff] [blame] | 287 | # Send pid to client process |
| 288 | try: |
| 289 | write_signed(child_w, pid) |
| 290 | except BrokenPipeError: |
| 291 | # client vanished |
| 292 | pass |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 293 | pid_to_fd[pid] = child_w |
| 294 | os.close(child_r) |
| 295 | for fd in fds: |
| 296 | os.close(fd) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 297 | |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 298 | except OSError as e: |
| 299 | if e.errno != errno.ECONNABORTED: |
| 300 | raise |
| 301 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 302 | |
| 303 | def _serve_one(child_r, fds, unused_fds, handlers): |
Antoine Pitrou | 6dd4d73 | 2017-05-04 16:44:53 +0200 | [diff] [blame] | 304 | # close unnecessary stuff and reset signal handlers |
Antoine Pitrou | 2b5cc5e | 2017-06-13 09:46:06 +0200 | [diff] [blame] | 305 | signal.set_wakeup_fd(-1) |
Antoine Pitrou | 6dd4d73 | 2017-05-04 16:44:53 +0200 | [diff] [blame] | 306 | for sig, val in handlers.items(): |
| 307 | signal.signal(sig, val) |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 308 | for fd in unused_fds: |
| 309 | os.close(fd) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 310 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 311 | (_forkserver._forkserver_alive_fd, |
Pierre Glaser | f22cc69 | 2019-05-10 22:59:08 +0200 | [diff] [blame] | 312 | resource_tracker._resource_tracker._fd, |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 313 | *_forkserver._inherited_fds) = fds |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 314 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 315 | # Run process object received over pipe |
Thomas Moreau | c09a9f5 | 2019-05-20 21:37:05 +0200 | [diff] [blame] | 316 | parent_sentinel = os.dup(child_r) |
| 317 | code = spawn._main(child_r, parent_sentinel) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 318 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 319 | return code |
| 320 | |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 321 | |
| 322 | # |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 323 | # Read and write signed numbers |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 324 | # |
| 325 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 326 | def read_signed(fd): |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 327 | data = b'' |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 328 | length = SIGNED_STRUCT.size |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 329 | while len(data) < length: |
Charles-François Natali | 6e6c59b | 2015-02-07 13:27:50 +0000 | [diff] [blame] | 330 | s = os.read(fd, length - len(data)) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 331 | if not s: |
| 332 | raise EOFError('unexpected EOF') |
| 333 | data += s |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 334 | return SIGNED_STRUCT.unpack(data)[0] |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 335 | |
Antoine Pitrou | dfd5f34 | 2017-06-12 15:28:19 +0200 | [diff] [blame] | 336 | def write_signed(fd, n): |
| 337 | msg = SIGNED_STRUCT.pack(n) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 338 | while msg: |
Charles-François Natali | 6e6c59b | 2015-02-07 13:27:50 +0000 | [diff] [blame] | 339 | nbytes = os.write(fd, msg) |
Richard Oudkerk | 84ed9a6 | 2013-08-14 15:35:41 +0100 | [diff] [blame] | 340 | if nbytes == 0: |
| 341 | raise RuntimeError('should not get here') |
| 342 | msg = msg[nbytes:] |
Richard Oudkerk | b1694cf | 2013-10-16 16:41:56 +0100 | [diff] [blame] | 343 | |
| 344 | # |
| 345 | # |
| 346 | # |
| 347 | |
| 348 | _forkserver = ForkServer() |
| 349 | ensure_running = _forkserver.ensure_running |
| 350 | get_inherited_fds = _forkserver.get_inherited_fds |
| 351 | connect_to_new_process = _forkserver.connect_to_new_process |
| 352 | set_forkserver_preload = _forkserver.set_forkserver_preload |