def __init__(self, node): """ :param node: The node singleton for this node controller session. :type node: obj """ NativeProcessSession.__init__(self) #self.debug = node.debug self.debug = False self.debug_app = False ## associated node self._node = node self._node_id = node._node_id self._realm = node._realm self.cbdir = self._node._cbdir self._created = utcnow() self._pid = os.getpid() ## map of worker processes: worker_id -> NativeWorkerProcess self._workers = {} self._management_transport = None exit = Deferred()
def onConnect(self): """ Called when the worker has connected to the node's management router. """ self._node_id = self.config.extra.node self._uri_prefix = 'crossbar.node.{}.worker.{}'.format( self.config.extra.node, self.config.extra.worker) NativeProcessSession.onConnect(self, False) self._module_tracker = TrackingModuleReloader() self._profiles = {} # flag indicating when worker is shutting down self._is_shutting_down = False # Jinja2 templates for Web (like WS status page et al) # templates_dir = os.path.abspath( pkg_resources.resource_filename("crossbar", "web/templates")) self.log.debug("Using Web templates from {templates_dir}", templates_dir=templates_dir) self._templates = jinja2.Environment( loader=jinja2.FileSystemLoader(templates_dir)) self.join(self.config.realm)
def onConnect(self): """ Called when the worker has connected to the node's management router. """ self._node_id = self.config.extra.node self._worker_id = self.config.extra.worker self._uri_prefix = u'crossbar.worker.{}'.format(self._worker_id) NativeProcessSession.onConnect(self, False) self._module_tracker = TrackingModuleReloader(snapshot=False) self._profiles = {} # flag indicating when worker is shutting down self._is_shutting_down = False # Jinja2 templates for Web (like WS status page et al) # templates_dir = os.path.abspath(pkg_resources.resource_filename("crossbar", "web/templates")) self.log.debug("Using Web templates from {templates_dir}", templates_dir=templates_dir) self._templates = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_dir)) self.join(self.config.realm)
def onConnect(self): self.log.debug("Connected to node management router") NativeProcessSession.onConnect(self, False) # self.join(self.config.realm) self.join(self._realm)
def onConnect(self): # self._uri_prefix = 'crossbar.node.{}'.format(self.config.extra.node) self._uri_prefix = 'crossbar.node.{}'.format(self._node_id) NativeProcessSession.onConnect(self, False) # self.join(self.config.realm) self.join(self._realm)
def onConnect(self): #self._uri_prefix = 'crossbar.node.{}'.format(self.config.extra.node) self._uri_prefix = 'crossbar.node.{}'.format(self._node_id) NativeProcessSession.onConnect(self, False) #self.join(self.config.realm) self.join(self._realm)
def onConnect(self): self.log.debug("Connected to node management router") # self._uri_prefix = u'crossbar.node.{}'.format(self.config.extra.node) self._uri_prefix = u'crossbar.node.{}'.format(self._node_id) NativeProcessSession.onConnect(self, False) # self.join(self.config.realm) self.join(self._realm)
def onConnect(self): """ Called when the worker has connected to the node's management router. """ self._uri_prefix = 'crossbar.node.{}.worker.{}'.format(self.config.extra.node, self.config.extra.worker) NativeProcessSession.onConnect(self, False) self._module_tracker = TrackingModuleReloader(debug=True) self.join(self.config.realm)
def onJoin(self, details, publish_ready = True): """ Called when worker process has joined the node's management realm. """ yield NativeProcessSession.onJoin(self, details) procs = [ 'get_cpu_affinity', 'set_cpu_affinity', 'get_pythonpath', 'add_pythonpath', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) if self.debug: log.msg("Registering procedure '{}'".format(uri)) dl.append(self.register(getattr(self, proc), uri, options = RegisterOptions(details_arg = 'details', discloseCaller = True))) regs = yield DeferredList(dl) if self.debug: log.msg("{} registered {} procedures".format(self.__class__.__name__, len(regs))) if publish_ready: yield self.publish_ready()
def onJoin(self, details, publish_ready=True): """ Called when worker process has joined the node's management realm. """ yield NativeProcessSession.onJoin(self, details) procs = [ # CPU affinity for this worker process 'get_cpu_affinity', 'set_cpu_affinity', # PYTHONPATH used for this worker 'get_pythonpath', 'add_pythonpath', # profiling control 'get_profilers', 'start_profiler', 'query_profile', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) if publish_ready: yield self.publish_ready()
def onJoin(self, details): # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: log.msg( "INTERNAL ERROR: on_worker_ready() fired for process {} - ready already called" .format(id)) else: log.msg( "INTERNAL ERROR: on_worker_ready() fired for process {} - no process with that ID" .format(id)) self.subscribe( on_worker_ready, 'crossbar.node.{}.on_worker_ready'.format(self._node_id)) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # procs = [ 'shutdown', 'start_management_transport', 'get_info', 'get_workers', 'get_worker_log', 'start_router', 'stop_router', 'start_container', 'stop_container', 'start_guest', 'stop_guest', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) if self.debug: log.msg("Registering procedure '{}'".format(uri)) dl.append( self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) if self.debug: log.msg("{} registered {} procedures".format( self.__class__.__name__, len(regs)))
def onJoin(self, details, publish_ready=True): """ Called when worker process has joined the node's management realm. """ yield NativeProcessSession.onJoin(self, details) procs = [ 'get_cpu_affinity', 'set_cpu_affinity', 'get_pythonpath', 'add_pythonpath', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) if self.debug: log.msg("Registering procedure '{}'".format(uri)) dl.append( self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) if self.debug: log.msg("{} registered {} procedures".format( self.__class__.__name__, len(regs))) if publish_ready: yield self.publish_ready()
def onJoin(self, details): self.log.info("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=id) self.subscribe(on_worker_ready, 'crossbar.node.{}.on_worker_ready'.format(self._node_id)) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # procs = [ 'shutdown', 'get_info', 'get_workers', 'get_worker_log', 'start_router', 'stop_router', 'start_container', 'stop_container', 'start_guest', 'stop_guest', 'start_websocket_testee', 'stop_websocket_testee', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) self._started = utcnow() self.publish(u"crossbar.node.on_ready", self._node_id) self.log.debug("Node controller ready")
def onJoin(self, details): self.log.info("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=id) self.subscribe(on_worker_ready, 'crossbar.node.{}.on_worker_ready'.format(self._node_id)) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # procs = [ 'shutdown', 'get_info', 'get_workers', 'get_worker_log', 'start_router', 'stop_router', 'start_container', 'stop_container', 'start_guest', 'stop_guest', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) self._started = utcnow() self.publish(u"crossbar.node.on_ready", self._node_id) self.log.debug("Node controller ready")
def onJoin(self, details): from autobahn.wamp.types import SubscribeOptions self.log.info("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error( "Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=id) else: self.log.error( "Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=id) self.subscribe(on_worker_ready, u'crossbar.worker..on_worker_ready', SubscribeOptions(match=u'wildcard')) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # dl = [] for proc in self.PROCS: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.info('Registering management API procedure "{proc}"', proc=uri) dl.append( self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) self._started = utcnow() self.publish(u"crossbar.on_ready") self.log.debug("Node controller ready")
def onConnect(self): """ Called when the worker has connected to the node's management router. """ self._uri_prefix = 'crossbar.node.{}.worker.{}'.format(self.config.extra.node, self.config.extra.worker) NativeProcessSession.onConnect(self, False) self._module_tracker = TrackingModuleReloader(debug=True) self._profiles = {} # Jinja2 templates for Web (like WS status page et al) # templates_dir = os.path.abspath(pkg_resources.resource_filename("crossbar", "web/templates")) self.log.debug("Using Web templates from {templates_dir}", templates_dir=templates_dir) self._templates = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_dir)) self.join(self.config.realm)
def __init__(self, node): """ :param node: The node singleton for this node controller session. :type node: obj """ NativeProcessSession.__init__(self, reactor=node._reactor) # associated node self._node = node self._node_id = node._node_id self._realm = node._realm self.cbdir = self._node._cbdir self._started = None self._pid = os.getpid() # map of worker processes: worker_id -> NativeWorkerProcess self._workers = {} self._shutdown_requested = False
def onJoin(self, details): # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error("INTERNAL ERROR: on_worker_ready() fired for process {process} - ready already called", process=id) else: self.log.error("INTERNAL ERROR: on_worker_ready() fired for process {process} - no process with that ID", process=id) self.subscribe(on_worker_ready, 'crossbar.node.{}.on_worker_ready'.format(self._node_id)) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # procs = [ 'shutdown', 'start_management_transport', 'get_info', 'get_workers', 'get_worker_log', 'start_router', 'stop_router', 'start_container', 'stop_container', 'start_guest', 'stop_guest', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering procedure '{uri}'", uri=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("{me} registered {registers} procedures", me=self.__class__.__name__, registers=len(regs))
def onJoin(self, details, publish_ready=True): """ Called when worker process has joined the node's management realm. """ yield NativeProcessSession.onJoin(self, details) procs = [ # orderly shutdown worker "from inside" 'shutdown', # CPU affinity for this worker process 'get_cpu_count', 'get_cpu_affinity', 'set_cpu_affinity', # PYTHONPATH used for this worker 'get_pythonpath', 'add_pythonpath', # profiling control 'get_profilers', 'start_profiler', 'get_profile', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append( self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) # setup SIGTERM handler to orderly shutdown the worker def shutdown(sig, frame): self.log.warn("Native worker received SIGTERM - shutting down ..") self.shutdown() signal.signal(signal.SIGTERM, shutdown) # the worker is ready for work! if publish_ready: yield self.publish_ready()
def onJoin(self, details): from autobahn.wamp.types import SubscribeOptions self.log.debug("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): worker_id = res['id'] if worker_id in self._workers: ready = self._workers[worker_id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(worker_id) else: self.log.error( "Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=worker_id) else: self.log.error( "Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=worker_id) self.subscribe(on_worker_ready, u'crossbar.worker..on_worker_ready', SubscribeOptions(match=u'wildcard')) yield NativeProcessSession.onJoin(self, details) # above upcall registers procedures we have marked with @wamp.register(None) # we need to catch SIGINT here to properly shutdown the # node explicitly (a Twisted system trigger wouldn't allow us to distinguish # different reasons/origins of exiting ..) def signal_handler(signal, frame): # the following will shutdown the Twisted reactor in the end self.shutdown() signal.signal(signal.SIGINT, signal_handler) self._started = utcnow() self.publish(u"crossbar.on_ready") self.log.debug("Node controller ready")
def onJoin(self, details, publish_ready=True): """ Called when worker process has joined the node's management realm. """ yield NativeProcessSession.onJoin(self, details) # above upcall registers all our "@wamp.register(None)" methods # setup SIGTERM handler to orderly shutdown the worker def shutdown(sig, frame): self.log.warn("Native worker received SIGTERM - shutting down ..") self.shutdown() signal.signal(signal.SIGTERM, shutdown) # the worker is ready for work! if publish_ready: yield self.publish_ready()
def onJoin(self, details, publish_ready=True): """ Called when worker process has joined the node's management realm. """ yield NativeProcessSession.onJoin(self, details) procs = [ # orderly shutdown worker "from inside" 'shutdown', # CPU affinity for this worker process 'get_cpu_count', 'get_cpu_affinity', 'set_cpu_affinity', # PYTHONPATH used for this worker 'get_pythonpath', 'add_pythonpath', # profiling control 'get_profilers', 'start_profiler', 'get_profile', ] dl = [] for proc in procs: uri = '{}.{}'.format(self._uri_prefix, proc) self.log.debug("Registering management API procedure {proc}", proc=uri) dl.append(self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) # setup SIGTERM handler to orderly shutdown the worker def shutdown(sig, frame): self.log.warn("Native worker received SIGTERM - shutting down ..") self.shutdown() signal.signal(signal.SIGTERM, shutdown) # the worker is ready for work! if publish_ready: yield self.publish_ready()
def onJoin(self, details): from autobahn.wamp.types import SubscribeOptions self.log.debug("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): worker_id = res['id'] if worker_id in self._workers: ready = self._workers[worker_id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(worker_id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=worker_id) else: self.log.error("Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=worker_id) self.subscribe(on_worker_ready, u'crossbar.worker..on_worker_ready', SubscribeOptions(match=u'wildcard')) yield NativeProcessSession.onJoin(self, details) # above upcall registers procedures we have marked with @wamp.register(None) # we need to catch SIGINT here to properly shutdown the # node explicitly (a Twisted system trigger wouldn't allow us to distinguish # different reasons/origins of exiting ..) def signal_handler(signal, frame): # the following will shutdown the Twisted reactor in the end self.shutdown() signal.signal(signal.SIGINT, signal_handler) self._started = utcnow() self.publish(u"crossbar.on_ready") self.log.debug("Node controller ready")
def onJoin(self, details): from autobahn.wamp.types import SubscribeOptions self.log.debug("Joined realm '{realm}' on node management router", realm=details.realm) # When a (native) worker process has connected back to the router of # the node controller, the worker will publish this event # to signal it's readyness. # def on_worker_ready(res): id = res['id'] if id in self._workers: ready = self._workers[id].ready if not ready.called: # fire the Deferred previously stored for # signaling "worker ready" ready.callback(id) else: self.log.error( "Internal error: on_worker_ready() fired for process {process}, but already called earlier", process=id) else: self.log.error( "Internal error: on_worker_ready() fired for process {process}, but no process with that ID", process=id) self.subscribe(on_worker_ready, u'crossbar.worker..on_worker_ready', SubscribeOptions(match=u'wildcard')) yield NativeProcessSession.onJoin(self, details) # register node controller procedures: 'crossbar.node.<ID>.<PROCEDURE>' # dl = [] for proc in self.PROCS: uri = u'{}.{}'.format(self._uri_prefix, proc) self.log.debug('Registering management API procedure "{proc}"', proc=uri) dl.append( self.register(getattr(self, proc), uri, options=RegisterOptions(details_arg='details'))) regs = yield DeferredList(dl) self.log.debug("Registered {cnt} management API procedures", cnt=len(regs)) # we need to catch SIGINT here to properly shutdown the # node explicitly (a Twisted system trigger wouldn't allow us to distinguish # different reasons/origins of exiting ..) def signal_handler(signal, frame): # the following will shutdown the Twisted reactor in the end self.shutdown() signal.signal(signal.SIGINT, signal_handler) self._started = utcnow() self.publish(u"crossbar.on_ready") self.log.debug("Node controller ready")