process.py 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  1. #
  2. # BitBake Process based server.
  3. #
  4. # Copyright (C) 2010 Bob Foerster <robert@erafx.com>
  5. #
  6. # SPDX-License-Identifier: GPL-2.0-only
  7. #
  8. """
  9. This module implements a multiprocessing.Process based server for bitbake.
  10. """
  11. import bb
  12. import bb.event
  13. import logging
  14. import multiprocessing
  15. import threading
  16. import array
  17. import os
  18. import sys
  19. import time
  20. import select
  21. import socket
  22. import subprocess
  23. import errno
  24. import re
  25. import datetime
  26. import pickle
  27. import bb.server.xmlrpcserver
  28. from bb import daemonize
  29. from multiprocessing import queues
  30. logger = logging.getLogger('BitBake')
  31. class ProcessTimeout(SystemExit):
  32. pass
  33. class ProcessServer():
  34. profile_filename = "profile.log"
  35. profile_processed_filename = "profile.log.processed"
  36. def __init__(self, lock, lockname, sock, sockname, server_timeout, xmlrpcinterface):
  37. self.command_channel = False
  38. self.command_channel_reply = False
  39. self.quit = False
  40. self.heartbeat_seconds = 1 # default, BB_HEARTBEAT_EVENT will be checked once we have a datastore.
  41. self.next_heartbeat = time.time()
  42. self.event_handle = None
  43. self.hadanyui = False
  44. self.haveui = False
  45. self.maxuiwait = 30
  46. self.xmlrpc = False
  47. self._idlefuns = {}
  48. self.bitbake_lock = lock
  49. self.bitbake_lock_name = lockname
  50. self.sock = sock
  51. self.sockname = sockname
  52. self.server_timeout = server_timeout
  53. self.timeout = self.server_timeout
  54. self.xmlrpcinterface = xmlrpcinterface
  55. def register_idle_function(self, function, data):
  56. """Register a function to be called while the server is idle"""
  57. assert hasattr(function, '__call__')
  58. self._idlefuns[function] = data
  59. def run(self):
  60. if self.xmlrpcinterface[0]:
  61. self.xmlrpc = bb.server.xmlrpcserver.BitBakeXMLRPCServer(self.xmlrpcinterface, self.cooker, self)
  62. print("Bitbake XMLRPC server address: %s, server port: %s" % (self.xmlrpc.host, self.xmlrpc.port))
  63. try:
  64. self.bitbake_lock.seek(0)
  65. self.bitbake_lock.truncate()
  66. if self.xmlrpc:
  67. self.bitbake_lock.write("%s %s:%s\n" % (os.getpid(), self.xmlrpc.host, self.xmlrpc.port))
  68. else:
  69. self.bitbake_lock.write("%s\n" % (os.getpid()))
  70. self.bitbake_lock.flush()
  71. except Exception as e:
  72. print("Error writing to lock file: %s" % str(e))
  73. pass
  74. if self.cooker.configuration.profile:
  75. try:
  76. import cProfile as profile
  77. except:
  78. import profile
  79. prof = profile.Profile()
  80. ret = profile.Profile.runcall(prof, self.main)
  81. prof.dump_stats("profile.log")
  82. bb.utils.process_profilelog("profile.log")
  83. print("Raw profiling information saved to profile.log and processed statistics to profile.log.processed")
  84. else:
  85. ret = self.main()
  86. return ret
  87. def main(self):
  88. self.cooker.pre_serve()
  89. bb.utils.set_process_name("Cooker")
  90. ready = []
  91. newconnections = []
  92. self.controllersock = False
  93. fds = [self.sock]
  94. if self.xmlrpc:
  95. fds.append(self.xmlrpc)
  96. seendata = False
  97. print("Entering server connection loop")
  98. def disconnect_client(self, fds):
  99. print("Disconnecting Client")
  100. if self.controllersock:
  101. fds.remove(self.controllersock)
  102. self.controllersock.close()
  103. self.controllersock = False
  104. if self.haveui:
  105. fds.remove(self.command_channel)
  106. bb.event.unregister_UIHhandler(self.event_handle, True)
  107. self.command_channel_reply.writer.close()
  108. self.event_writer.writer.close()
  109. self.command_channel.close()
  110. self.command_channel = False
  111. del self.event_writer
  112. self.lastui = time.time()
  113. self.cooker.clientComplete()
  114. self.haveui = False
  115. ready = select.select(fds,[],[],0)[0]
  116. if newconnections:
  117. print("Starting new client")
  118. conn = newconnections.pop(-1)
  119. fds.append(conn)
  120. self.controllersock = conn
  121. elif self.timeout is None and not ready:
  122. print("No timeout, exiting.")
  123. self.quit = True
  124. self.lastui = time.time()
  125. while not self.quit:
  126. if self.sock in ready:
  127. while select.select([self.sock],[],[],0)[0]:
  128. controllersock, address = self.sock.accept()
  129. if self.controllersock:
  130. print("Queuing %s (%s)" % (str(ready), str(newconnections)))
  131. newconnections.append(controllersock)
  132. else:
  133. print("Accepting %s (%s)" % (str(ready), str(newconnections)))
  134. self.controllersock = controllersock
  135. fds.append(controllersock)
  136. if self.controllersock in ready:
  137. try:
  138. print("Processing Client")
  139. ui_fds = recvfds(self.controllersock, 3)
  140. print("Connecting Client")
  141. # Where to write events to
  142. writer = ConnectionWriter(ui_fds[0])
  143. self.event_handle = bb.event.register_UIHhandler(writer, True)
  144. self.event_writer = writer
  145. # Where to read commands from
  146. reader = ConnectionReader(ui_fds[1])
  147. fds.append(reader)
  148. self.command_channel = reader
  149. # Where to send command return values to
  150. writer = ConnectionWriter(ui_fds[2])
  151. self.command_channel_reply = writer
  152. self.haveui = True
  153. self.hadanyui = True
  154. except (EOFError, OSError):
  155. disconnect_client(self, fds)
  156. if not self.timeout == -1.0 and not self.haveui and self.timeout and \
  157. (self.lastui + self.timeout) < time.time():
  158. print("Server timeout, exiting.")
  159. self.quit = True
  160. # If we don't see a UI connection within maxuiwait, its unlikely we're going to see
  161. # one. We have had issue with processes hanging indefinitely so timing out UI-less
  162. # servers is useful.
  163. if not self.hadanyui and not self.xmlrpc and not self.timeout and (self.lastui + self.maxuiwait) < time.time():
  164. print("No UI connection within max timeout, exiting to avoid infinite loop.")
  165. self.quit = True
  166. if self.command_channel in ready:
  167. try:
  168. command = self.command_channel.get()
  169. except EOFError:
  170. # Client connection shutting down
  171. ready = []
  172. disconnect_client(self, fds)
  173. continue
  174. if command[0] == "terminateServer":
  175. self.quit = True
  176. continue
  177. try:
  178. print("Running command %s" % command)
  179. self.command_channel_reply.send(self.cooker.command.runCommand(command))
  180. except Exception as e:
  181. logger.exception('Exception in server main event loop running command %s (%s)' % (command, str(e)))
  182. if self.xmlrpc in ready:
  183. self.xmlrpc.handle_requests()
  184. if not seendata and hasattr(self.cooker, "data"):
  185. heartbeat_event = self.cooker.data.getVar('BB_HEARTBEAT_EVENT')
  186. if heartbeat_event:
  187. try:
  188. self.heartbeat_seconds = float(heartbeat_event)
  189. except:
  190. bb.warn('Ignoring invalid BB_HEARTBEAT_EVENT=%s, must be a float specifying seconds.' % heartbeat_event)
  191. self.timeout = self.server_timeout or self.cooker.data.getVar('BB_SERVER_TIMEOUT')
  192. try:
  193. if self.timeout:
  194. self.timeout = float(self.timeout)
  195. except:
  196. bb.warn('Ignoring invalid BB_SERVER_TIMEOUT=%s, must be a float specifying seconds.' % self.timeout)
  197. seendata = True
  198. ready = self.idle_commands(.1, fds)
  199. if len(threading.enumerate()) != 1:
  200. print("More than one thread left?: " + str(threading.enumerate()))
  201. print("Exiting")
  202. # Remove the socket file so we don't get any more connections to avoid races
  203. try:
  204. os.unlink(self.sockname)
  205. except:
  206. pass
  207. self.sock.close()
  208. try:
  209. self.cooker.shutdown(True)
  210. self.cooker.notifier.stop()
  211. self.cooker.confignotifier.stop()
  212. except:
  213. pass
  214. self.cooker.post_serve()
  215. # Flush logs before we release the lock
  216. sys.stdout.flush()
  217. sys.stderr.flush()
  218. # Finally release the lockfile but warn about other processes holding it open
  219. lock = self.bitbake_lock
  220. lockfile = self.bitbake_lock_name
  221. lock.close()
  222. lock = None
  223. while not lock:
  224. with bb.utils.timeout(3):
  225. lock = bb.utils.lockfile(lockfile, shared=False, retry=False, block=True)
  226. if lock:
  227. # We hold the lock so we can remove the file (hide stale pid data)
  228. # via unlockfile.
  229. bb.utils.unlockfile(lock)
  230. return
  231. if not lock:
  232. # Some systems may not have lsof available
  233. procs = None
  234. try:
  235. procs = subprocess.check_output(["lsof", '-w', lockfile], stderr=subprocess.STDOUT)
  236. except OSError as e:
  237. if e.errno != errno.ENOENT:
  238. raise
  239. if procs is None:
  240. # Fall back to fuser if lsof is unavailable
  241. try:
  242. procs = subprocess.check_output(["fuser", '-v', lockfile], stderr=subprocess.STDOUT)
  243. except OSError as e:
  244. if e.errno != errno.ENOENT:
  245. raise
  246. msg = "Delaying shutdown due to active processes which appear to be holding bitbake.lock"
  247. if procs:
  248. msg += ":\n%s" % str(procs)
  249. print(msg)
  250. def idle_commands(self, delay, fds=None):
  251. nextsleep = delay
  252. if not fds:
  253. fds = []
  254. for function, data in list(self._idlefuns.items()):
  255. try:
  256. retval = function(self, data, False)
  257. if retval is False:
  258. del self._idlefuns[function]
  259. nextsleep = None
  260. elif retval is True:
  261. nextsleep = None
  262. elif isinstance(retval, float) and nextsleep:
  263. if (retval < nextsleep):
  264. nextsleep = retval
  265. elif nextsleep is None:
  266. continue
  267. else:
  268. fds = fds + retval
  269. except SystemExit:
  270. raise
  271. except Exception as exc:
  272. if not isinstance(exc, bb.BBHandledException):
  273. logger.exception('Running idle function')
  274. del self._idlefuns[function]
  275. self.quit = True
  276. # Create new heartbeat event?
  277. now = time.time()
  278. if now >= self.next_heartbeat:
  279. # We might have missed heartbeats. Just trigger once in
  280. # that case and continue after the usual delay.
  281. self.next_heartbeat += self.heartbeat_seconds
  282. if self.next_heartbeat <= now:
  283. self.next_heartbeat = now + self.heartbeat_seconds
  284. if hasattr(self.cooker, "data"):
  285. heartbeat = bb.event.HeartbeatEvent(now)
  286. bb.event.fire(heartbeat, self.cooker.data)
  287. if nextsleep and now + nextsleep > self.next_heartbeat:
  288. # Shorten timeout so that we we wake up in time for
  289. # the heartbeat.
  290. nextsleep = self.next_heartbeat - now
  291. if nextsleep is not None:
  292. if self.xmlrpc:
  293. nextsleep = self.xmlrpc.get_timeout(nextsleep)
  294. try:
  295. return select.select(fds,[],[],nextsleep)[0]
  296. except InterruptedError:
  297. # Ignore EINTR
  298. return []
  299. else:
  300. return select.select(fds,[],[],0)[0]
  301. class ServerCommunicator():
  302. def __init__(self, connection, recv):
  303. self.connection = connection
  304. self.recv = recv
  305. def runCommand(self, command):
  306. self.connection.send(command)
  307. if not self.recv.poll(30):
  308. logger.info("No reply from server in 30s")
  309. if not self.recv.poll(30):
  310. raise ProcessTimeout("Timeout while waiting for a reply from the bitbake server (60s)")
  311. return self.recv.get()
  312. def updateFeatureSet(self, featureset):
  313. _, error = self.runCommand(["setFeatures", featureset])
  314. if error:
  315. logger.error("Unable to set the cooker to the correct featureset: %s" % error)
  316. raise BaseException(error)
  317. def getEventHandle(self):
  318. handle, error = self.runCommand(["getUIHandlerNum"])
  319. if error:
  320. logger.error("Unable to get UI Handler Number: %s" % error)
  321. raise BaseException(error)
  322. return handle
  323. def terminateServer(self):
  324. self.connection.send(['terminateServer'])
  325. return
  326. class BitBakeProcessServerConnection(object):
  327. def __init__(self, ui_channel, recv, eq, sock):
  328. self.connection = ServerCommunicator(ui_channel, recv)
  329. self.events = eq
  330. # Save sock so it doesn't get gc'd for the life of our connection
  331. self.socket_connection = sock
  332. def terminate(self):
  333. self.socket_connection.close()
  334. self.connection.connection.close()
  335. self.connection.recv.close()
  336. return
  337. start_log_format = '--- Starting bitbake server pid %s at %s ---'
  338. start_log_datetime_format = '%Y-%m-%d %H:%M:%S.%f'
  339. class BitBakeServer(object):
  340. def __init__(self, lock, sockname, featureset, server_timeout, xmlrpcinterface):
  341. self.server_timeout = server_timeout
  342. self.xmlrpcinterface = xmlrpcinterface
  343. self.featureset = featureset
  344. self.sockname = sockname
  345. self.bitbake_lock = lock
  346. self.readypipe, self.readypipein = os.pipe()
  347. # Place the log in the builddirectory alongside the lock file
  348. logfile = os.path.join(os.path.dirname(self.bitbake_lock.name), "bitbake-cookerdaemon.log")
  349. self.logfile = logfile
  350. startdatetime = datetime.datetime.now()
  351. bb.daemonize.createDaemon(self._startServer, logfile)
  352. self.bitbake_lock.close()
  353. os.close(self.readypipein)
  354. ready = ConnectionReader(self.readypipe)
  355. r = ready.poll(5)
  356. if not r:
  357. bb.note("Bitbake server didn't start within 5 seconds, waiting for 90")
  358. r = ready.poll(90)
  359. if r:
  360. try:
  361. r = ready.get()
  362. except EOFError:
  363. # Trap the child exitting/closing the pipe and error out
  364. r = None
  365. if not r or r[0] != "r":
  366. ready.close()
  367. bb.error("Unable to start bitbake server (%s)" % str(r))
  368. if os.path.exists(logfile):
  369. logstart_re = re.compile(start_log_format % ('([0-9]+)', '([0-9-]+ [0-9:.]+)'))
  370. started = False
  371. lines = []
  372. lastlines = []
  373. with open(logfile, "r") as f:
  374. for line in f:
  375. if started:
  376. lines.append(line)
  377. else:
  378. lastlines.append(line)
  379. res = logstart_re.match(line.rstrip())
  380. if res:
  381. ldatetime = datetime.datetime.strptime(res.group(2), start_log_datetime_format)
  382. if ldatetime >= startdatetime:
  383. started = True
  384. lines.append(line)
  385. if len(lastlines) > 60:
  386. lastlines = lastlines[-60:]
  387. if lines:
  388. if len(lines) > 60:
  389. bb.error("Last 60 lines of server log for this session (%s):\n%s" % (logfile, "".join(lines[-60:])))
  390. else:
  391. bb.error("Server log for this session (%s):\n%s" % (logfile, "".join(lines)))
  392. elif lastlines:
  393. bb.error("Server didn't start, last 60 loglines (%s):\n%s" % (logfile, "".join(lastlines)))
  394. else:
  395. bb.error("%s doesn't exist" % logfile)
  396. raise SystemExit(1)
  397. ready.close()
  398. def _startServer(self):
  399. os.close(self.readypipe)
  400. os.set_inheritable(self.bitbake_lock.fileno(), True)
  401. os.set_inheritable(self.readypipein, True)
  402. serverscript = os.path.realpath(os.path.dirname(__file__) + "/../../../bin/bitbake-server")
  403. os.execl(serverscript, serverscript, "decafbad", str(self.bitbake_lock.fileno()), str(self.readypipein), self.logfile, self.bitbake_lock.name, self.sockname, str(self.server_timeout), str(self.xmlrpcinterface[0]), str(self.xmlrpcinterface[1]))
  404. def execServer(lockfd, readypipeinfd, lockname, sockname, server_timeout, xmlrpcinterface):
  405. import bb.cookerdata
  406. import bb.cooker
  407. print(start_log_format % (os.getpid(), datetime.datetime.now().strftime(start_log_datetime_format)))
  408. sys.stdout.flush()
  409. try:
  410. bitbake_lock = os.fdopen(lockfd, "w")
  411. # Create server control socket
  412. if os.path.exists(sockname):
  413. os.unlink(sockname)
  414. sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  415. # AF_UNIX has path length issues so chdir here to workaround
  416. cwd = os.getcwd()
  417. try:
  418. os.chdir(os.path.dirname(sockname))
  419. sock.bind(os.path.basename(sockname))
  420. finally:
  421. os.chdir(cwd)
  422. sock.listen(1)
  423. server = ProcessServer(bitbake_lock, lockname, sock, sockname, server_timeout, xmlrpcinterface)
  424. writer = ConnectionWriter(readypipeinfd)
  425. try:
  426. featureset = []
  427. cooker = bb.cooker.BBCooker(featureset, server.register_idle_function)
  428. except bb.BBHandledException:
  429. return None
  430. writer.send("r")
  431. writer.close()
  432. server.cooker = cooker
  433. print("Started bitbake server pid %d" % os.getpid())
  434. sys.stdout.flush()
  435. server.run()
  436. finally:
  437. # Flush any ,essages/errors to the logfile before exit
  438. sys.stdout.flush()
  439. sys.stderr.flush()
  440. def connectProcessServer(sockname, featureset):
  441. # Connect to socket
  442. sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  443. # AF_UNIX has path length issues so chdir here to workaround
  444. cwd = os.getcwd()
  445. readfd = writefd = readfd1 = writefd1 = readfd2 = writefd2 = None
  446. eq = command_chan_recv = command_chan = None
  447. sock.settimeout(10)
  448. try:
  449. try:
  450. os.chdir(os.path.dirname(sockname))
  451. finished = False
  452. while not finished:
  453. try:
  454. sock.connect(os.path.basename(sockname))
  455. finished = True
  456. except IOError as e:
  457. if e.errno == errno.EWOULDBLOCK:
  458. pass
  459. raise
  460. finally:
  461. os.chdir(cwd)
  462. # Send an fd for the remote to write events to
  463. readfd, writefd = os.pipe()
  464. eq = BBUIEventQueue(readfd)
  465. # Send an fd for the remote to recieve commands from
  466. readfd1, writefd1 = os.pipe()
  467. command_chan = ConnectionWriter(writefd1)
  468. # Send an fd for the remote to write commands results to
  469. readfd2, writefd2 = os.pipe()
  470. command_chan_recv = ConnectionReader(readfd2)
  471. sendfds(sock, [writefd, readfd1, writefd2])
  472. server_connection = BitBakeProcessServerConnection(command_chan, command_chan_recv, eq, sock)
  473. # Close the ends of the pipes we won't use
  474. for i in [writefd, readfd1, writefd2]:
  475. os.close(i)
  476. server_connection.connection.updateFeatureSet(featureset)
  477. except (Exception, SystemExit) as e:
  478. if command_chan_recv:
  479. command_chan_recv.close()
  480. if command_chan:
  481. command_chan.close()
  482. for i in [writefd, readfd1, writefd2]:
  483. try:
  484. if i:
  485. os.close(i)
  486. except OSError:
  487. pass
  488. sock.close()
  489. raise
  490. return server_connection
  491. def sendfds(sock, fds):
  492. '''Send an array of fds over an AF_UNIX socket.'''
  493. fds = array.array('i', fds)
  494. msg = bytes([len(fds) % 256])
  495. sock.sendmsg([msg], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fds)])
  496. def recvfds(sock, size):
  497. '''Receive an array of fds over an AF_UNIX socket.'''
  498. a = array.array('i')
  499. bytes_size = a.itemsize * size
  500. msg, ancdata, flags, addr = sock.recvmsg(1, socket.CMSG_LEN(bytes_size))
  501. if not msg and not ancdata:
  502. raise EOFError
  503. try:
  504. if len(ancdata) != 1:
  505. raise RuntimeError('received %d items of ancdata' %
  506. len(ancdata))
  507. cmsg_level, cmsg_type, cmsg_data = ancdata[0]
  508. if (cmsg_level == socket.SOL_SOCKET and
  509. cmsg_type == socket.SCM_RIGHTS):
  510. if len(cmsg_data) % a.itemsize != 0:
  511. raise ValueError
  512. a.frombytes(cmsg_data)
  513. assert len(a) % 256 == msg[0]
  514. return list(a)
  515. except (ValueError, IndexError):
  516. pass
  517. raise RuntimeError('Invalid data received')
  518. class BBUIEventQueue:
  519. def __init__(self, readfd):
  520. self.eventQueue = []
  521. self.eventQueueLock = threading.Lock()
  522. self.eventQueueNotify = threading.Event()
  523. self.reader = ConnectionReader(readfd)
  524. self.t = threading.Thread()
  525. self.t.setDaemon(True)
  526. self.t.run = self.startCallbackHandler
  527. self.t.start()
  528. def getEvent(self):
  529. self.eventQueueLock.acquire()
  530. if len(self.eventQueue) == 0:
  531. self.eventQueueLock.release()
  532. return None
  533. item = self.eventQueue.pop(0)
  534. if len(self.eventQueue) == 0:
  535. self.eventQueueNotify.clear()
  536. self.eventQueueLock.release()
  537. return item
  538. def waitEvent(self, delay):
  539. self.eventQueueNotify.wait(delay)
  540. return self.getEvent()
  541. def queue_event(self, event):
  542. self.eventQueueLock.acquire()
  543. self.eventQueue.append(event)
  544. self.eventQueueNotify.set()
  545. self.eventQueueLock.release()
  546. def send_event(self, event):
  547. self.queue_event(pickle.loads(event))
  548. def startCallbackHandler(self):
  549. bb.utils.set_process_name("UIEventQueue")
  550. while True:
  551. try:
  552. self.reader.wait()
  553. event = self.reader.get()
  554. self.queue_event(event)
  555. except EOFError:
  556. # Easiest way to exit is to close the file descriptor to cause an exit
  557. break
  558. self.reader.close()
  559. class ConnectionReader(object):
  560. def __init__(self, fd):
  561. self.reader = multiprocessing.connection.Connection(fd, writable=False)
  562. self.rlock = multiprocessing.Lock()
  563. def wait(self, timeout=None):
  564. return multiprocessing.connection.wait([self.reader], timeout)
  565. def poll(self, timeout=None):
  566. return self.reader.poll(timeout)
  567. def get(self):
  568. with self.rlock:
  569. res = self.reader.recv_bytes()
  570. return multiprocessing.reduction.ForkingPickler.loads(res)
  571. def fileno(self):
  572. return self.reader.fileno()
  573. def close(self):
  574. return self.reader.close()
  575. class ConnectionWriter(object):
  576. def __init__(self, fd):
  577. self.writer = multiprocessing.connection.Connection(fd, readable=False)
  578. self.wlock = multiprocessing.Lock()
  579. # Why bb.event needs this I have no idea
  580. self.event = self
  581. def send(self, obj):
  582. obj = multiprocessing.reduction.ForkingPickler.dumps(obj)
  583. with self.wlock:
  584. self.writer.send_bytes(obj)
  585. def fileno(self):
  586. return self.writer.fileno()
  587. def close(self):
  588. return self.writer.close()