def add_realm_to_router(router_factory, session_factory, realm_name=u'default',
realm_options={}):
opts = dict(realm_options)
opts.update({u'name': realm_name})
# start a realm
realm = RouterRealm(None, None, opts)
router = router_factory.start_realm(realm)
extra = {}
session_config = ComponentConfig(realm_name, extra)
realm.session = RouterServiceAgent(session_config, router)
# allow everything
default_permissions = {
u'uri': u'',
u'match': u'prefix',
u'allow': {
u'call': True,
u'register': True,
u'publish': True,
u'subscribe': True
}
}
router = router_factory.get(realm_name)
router.add_role(RouterRoleStaticAuth(router, 'anonymous', default_permissions=default_permissions))
session_factory.add(realm.session, router, authrole=u'trusted')
return router
def add_realm_to_router(router_factory, session_factory, realm_name='default',
realm_options={}):
opts = dict(realm_options)
opts.update({'name': realm_name})
# start a realm
realm = RouterRealm(None, None, opts)
router = router_factory.start_realm(realm)
extra = {}
session_config = ComponentConfig(realm_name, extra)
realm.session = RouterServiceAgent(session_config, router)
# allow everything
default_permissions = {
'uri': '',
'match': 'prefix',
'allow': {
'call': True,
'register': True,
'publish': True,
'subscribe': True
}
}
router = router_factory.get(realm_name)
router.add_role(RouterRoleStaticAuth(router, 'anonymous', default_permissions=default_permissions))
session_factory.add(realm.session, router, authrole='trusted')
return router
def start(self, node_id=None):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
The node keys (``load_keys``) and configuration (``load_config``) has to be loaded
before starting the node.
This is the _third_ function being called after the Node has been instantiated.
"""
self.log.info('Starting {personality} node {method}',
personality=self.personality.NAME,
method=hltype(Node.start))
# a configuration must have been loaded before
if not self._config:
raise Exception("No node configuration set")
# a node can only be started once for now
assert self._shutdown_complete is None
assert self._node_id is None
# get controller config/options
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
# the node ID: CLI takes precedence over config over hostname
if node_id:
self._node_id = node_id
_node_id_source = 'explicit run-time argument'
elif 'id' in controller_config:
self._node_id = controller_config['id']
_node_id_source = 'explicit configuration'
else:
self._node_id = u'{}'.format(socket.gethostname()).lower()
_node_id_source = 'hostname'
self.log.info('Node ID {node_id} set from {node_id_source}',
node_id=hlid(self._node_id),
node_id_source=_node_id_source)
# set controller process title
try:
import setproctitle
except ImportError:
self.log.warn(
"Warning, could not set process title (setproctitle not installed)"
)
else:
setproctitle.setproctitle(
controller_options.get('title', 'crossbar-controller'))
# add the node controller singleton component
self._controller = self.NODE_CONTROLLER(self)
# local node management router
self._router_factory = RouterFactory(self._node_id, None)
self._router_session_factory = RouterSessionFactory(
self._router_factory)
rlm_config = {'name': self._realm}
rlm = RouterRealm(self._controller, None, rlm_config)
router = self._router_factory.start_realm(rlm)
# setup global static roles
self._add_global_roles()
# always add a realm service session
cfg = ComponentConfig(self._realm)
rlm.session = (self.ROUTER_SERVICE)(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
self.log.debug('Router service session attached [{router_service}]',
router_service=qual(self.ROUTER_SERVICE))
self._router_session_factory.add(self._controller, authrole=u'trusted')
self.log.debug('Node controller attached [{node_controller}]',
node_controller=qual(self.NODE_CONTROLLER))
# add extra node controller components
self._add_extra_controller_components(controller_options)
# setup Node shutdown triggers
self._set_shutdown_triggers(controller_options)
# setup node shutdown Deferred
self._shutdown_complete = Deferred()
# startup the node personality ..
yield self.personality.Node.boot(self)
# notify systemd that we are fully up and running
try:
import sdnotify
except ImportError:
# do nothing on non-systemd platforms
pass
else:
sdnotify.SystemdNotifier().notify("READY=1")
# return a shutdown deferred which we will fire to notify the code that
# called start() - which is the main crossbar boot code
res = {'shutdown_complete': self._shutdown_complete}
returnValue(res)
def start(self, node_id=None):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
self.log.info('Starting {personality} node {method}',
personality=self.personality.NAME,
method=hltype(Node.start))
# a configuration must have been loaded before
if not self._config:
raise Exception("No node configuration set")
# a node can only be started once for now
assert self._shutdown_complete is None
assert self._node_id is None
# get controller config/options
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
# the node ID: CLI takes precedence over config over hostname
if node_id:
self._node_id = node_id
_node_id_source = 'explicit run-time argument'
elif 'id' in controller_config:
self._node_id = controller_config['id']
_node_id_source = 'explicit configuration'
else:
self._node_id = u'{}'.format(socket.gethostname()).lower()
_node_id_source = 'hostname'
self.log.info('Node ID {node_id} set from {node_id_source}',
node_id=hlid(self._node_id),
node_id_source=_node_id_source)
# set controller process title
try:
import setproctitle
except ImportError:
self.log.warn("Warning, could not set process title (setproctitle not installed)")
else:
setproctitle.setproctitle(controller_options.get('title', 'crossbar-controller'))
# local node management router
self._router_factory = RouterFactory(self._node_id, None)
self._router_session_factory = RouterSessionFactory(self._router_factory)
rlm_config = {
'name': self._realm
}
rlm = RouterRealm(None, rlm_config)
router = self._router_factory.start_realm(rlm)
# setup global static roles
self._add_global_roles()
# always add a realm service session
cfg = ComponentConfig(self._realm)
rlm.session = (self.ROUTER_SERVICE)(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
self.log.debug('Router service session attached [{router_service}]', router_service=qual(self.ROUTER_SERVICE))
# add the node controller singleton component
self._controller = self.NODE_CONTROLLER(self)
self._router_session_factory.add(self._controller, authrole=u'trusted')
self.log.debug('Node controller attached [{node_controller}]', node_controller=qual(self.NODE_CONTROLLER))
# add extra node controller components
self._add_extra_controller_components(controller_options)
# setup Node shutdown triggers
self._set_shutdown_triggers(controller_options)
# setup node shutdown Deferred
self._shutdown_complete = Deferred()
# startup the node personality ..
yield self.personality.Node.boot(self)
# notify systemd that we are fully up and running
try:
import sdnotify
except ImportError:
# do nothing on non-systemd platforms
pass
else:
sdnotify.SystemdNotifier().notify("READY=1")
# return a shutdown deferred which we will fire to notify the code that
# called start() - which is the main crossbar boot code
res = {
'shutdown_complete': self._shutdown_complete
}
returnValue(res)
