import optparse
import warnings
-import signal
from traceback import format_exception
try:
import bb
from bb import cooker
from bb import ui
from bb import server
-from bb.server.process import ProcessServer, ServerCommunicator, ProcessEventQueue
-
-from Queue import Empty
-from multiprocessing import Queue, Pipe
+#from bb.server import none
+from bb.server import process
+#from bb.server import xmlrpc
__version__ = "1.13.0"
logger = logging.getLogger("BitBake")
ui_main = get_ui(configuration)
+ # Save a logfile for cooker into the current working directory. When the
+ # server is daemonized this logfile will be truncated.
+ cooker_logfile = os.path.join(os.getcwd(), "cooker.log")
+
bb.utils.init_logger(bb.msg, configuration.verbose, configuration.debug,
configuration.debug_domains)
# of the UIs (e.g. for DISPLAY, etc.)
bb.utils.clean_environment()
- # establish communication channels. We use bidirectional pipes for
- # ui <--> server command/response pairs
- # and a queue for server -> ui event notifications
- #
- ui_channel, server_channel = Pipe()
- event_queue = ProcessEventQueue()
+ #server = bb.server.none.BitBakeServer()
+ server = bb.server.process.BitBakeServer()
+ #server = bb.server.xmlrpc.BitBakeServer()
+
+ server.initServer()
+ idle = server.getServerIdleCB()
- server = ProcessServer(server_channel, event_queue, configuration)
- server.start()
+ cooker = bb.cooker.BBCooker(configuration, idle)
+ cooker.parseCommandLine()
+
+ server.addcooker(cooker)
+ server.saveConnectionDetails()
+ server.detach(cooker_logfile)
+
+ # Should no longer need to ever reference cooker
+ del cooker
logger.removeHandler(handler)
- def shutdown(force=False):
- signal.signal(signal.SIGINT, signal.SIG_IGN)
- server.stop()
- if force:
- server.join(0.5)
- if server.is_alive():
- server.terminate()
- server.join()
- else:
- server.join()
- while True:
- try:
- event = event_queue.get(block=False)
- except (Empty, IOError):
- break
- if isinstance(event, logging.LogRecord):
- logger.handle(event)
- ui_channel.close()
- event_queue.close()
- if force:
- sys.exit(1)
-
- signal.signal(signal.SIGTERM, lambda i, s: shutdown(force=True))
+ # Setup a connection to the server (cooker)
+ server_connection = server.establishConnection()
+
try:
- return ui_main(ServerCommunicator(ui_channel), event_queue)
+ return server.launchUI(ui_main, server_connection.connection, server_connection.events)
finally:
- shutdown()
+ server_connection.terminate()
return 1
import signal
import sys
import time
-from bb.cooker import BBCooker
from Queue import Empty
from multiprocessing import Event, Process, util, Queue, Pipe, queues
profile_filename = "profile.log"
profile_processed_filename = "profile.log.processed"
- def __init__(self, command_channel, event_queue, configuration):
+ def __init__(self, command_channel, event_queue):
Process.__init__(self)
self.command_channel = command_channel
self.event_queue = event_queue
self.event = EventAdapter(event_queue)
- self.configuration = configuration
- self.cooker = BBCooker(configuration, self.register_idle_function)
self._idlefunctions = {}
self.event_handle = bb.event.register_UIHhandler(self)
self.quit = False
if (2, 6, 0) <= sys.version_info < (2, 6, 3):
_bootstrap = bootstrap_2_6_6
+class BitBakeServerConnection():
+ def __init__(self, server):
+ self.server = server
+ self.procserver = server.server
+ self.connection = ServerCommunicator(server.ui_channel)
+ self.events = server.event_queue
+
+ def terminate(self, force = False):
+ signal.signal(signal.SIGINT, signal.SIG_IGN)
+ self.procserver.stop()
+ if force:
+ self.procserver.join(0.5)
+ if self.procserver.is_alive():
+ self.procserver.terminate()
+ self.procserver.join()
+ else:
+ self.procserver.join()
+ while True:
+ try:
+ event = self.server.event_queue.get(block=False)
+ except (Empty, IOError):
+ break
+ if isinstance(event, logging.LogRecord):
+ logger.handle(event)
+ self.server.ui_channel.close()
+ self.server.event_queue.close()
+ if force:
+ sys.exit(1)
+
# Wrap Queue to provide API which isn't server implementation specific
class ProcessEventQueue(multiprocessing.queues.Queue):
def waitEvent(self, timeout):
return None
+class BitBakeServer(object):
+ def initServer(self):
+ # establish communication channels. We use bidirectional pipes for
+ # ui <--> server command/response pairs
+ # and a queue for server -> ui event notifications
+ #
+ self.ui_channel, self.server_channel = Pipe()
+ self.event_queue = ProcessEventQueue(0)
+
+ self.server = ProcessServer(self.server_channel, self.event_queue)
+
+ def addcooker(self, cooker):
+ self.cooker = cooker
+ self.server.cooker = cooker
+
+ def getServerIdleCB(self):
+ return self.server.register_idle_function
+
+ def saveConnectionDetails(self):
+ return
+
+ def detach(self, cooker_logfile):
+ self.server.start()
+ return
+
+ def establishConnection(self):
+ self.connection = BitBakeServerConnection(self)
+ signal.signal(signal.SIGTERM, lambda i, s: self.connection.terminate(force=True))
+ return self.connection
+
+ def launchUI(self, uifunc, *args):
+ return bb.cooker.server_main(self.cooker, uifunc, *args)
return s
class BitBakeServerCommands():
- def __init__(self, server, cooker):
- self.cooker = cooker
+ def __init__(self, server):
self.server = server
def registerEventHandler(self, host, port):
"""
return True
-class BitBakeServer(SimpleXMLRPCServer):
+class BitBakeXMLRPCServer(SimpleXMLRPCServer):
# remove this when you're done with debugging
# allow_reuse_address = True
- def __init__(self, cooker, interface = ("localhost", 0)):
+ def __init__(self, interface = ("localhost", 0)):
"""
Constructor
"""
self._idlefuns = {}
self.host, self.port = self.socket.getsockname()
#self.register_introspection_functions()
- commands = BitBakeServerCommands(self, cooker)
- self.autoregister_all_functions(commands, "")
+ self.commands = BitBakeServerCommands(self)
+ self.autoregister_all_functions(self.commands, "")
+
+ def addcooker(self, cooker):
self.cooker = cooker
+ self.commands.cooker = cooker
def autoregister_all_functions(self, context, prefix):
"""
self.host = server.host
self.port = server.port
-class BitBakeServerFork():
- def __init__(self, cooker, server, serverinfo, logfile):
- daemonize.createDaemon(server.serve_forever, logfile)
-
-class BitbakeUILauch():
- def launch(self, serverinfo, uifunc, *args):
- return uifunc(*args)
-
class BitBakeServerConnection():
def __init__(self, serverinfo):
self.connection = _create_server(serverinfo.host, serverinfo.port)
self.connection.terminateServer()
except:
pass
+
+class BitBakeServer(object):
+ def initServer(self):
+ self.server = BitBakeXMLRPCServer()
+
+ def addcooker(self, cooker):
+ self.cooker = cooker
+ self.server.addcooker(cooker)
+
+ def getServerIdleCB(self):
+ return self.server.register_idle_function
+
+ def saveConnectionDetails(self):
+ self.serverinfo = BitbakeServerInfo(self.server)
+
+ def detach(self, cooker_logfile):
+ daemonize.createDaemon(self.server.serve_forever, cooker_logfile)
+ del self.cooker
+ del self.server
+
+ def establishConnection(self):
+ self.connection = BitBakeServerConnection(self.serverinfo)
+ return self.connection
+
+ def launchUI(self, uifunc, *args):
+ return uifunc(*args)
+
+
projects / thirdparty / openembedded / openembedded-core-contrib.git / commitdiff
