process.py 26 KB

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