def setUp(self):
"""
Setup router and router session factories.
"""
# create a router factory
self.router_factory = RouterFactory('node1', 'router1', None)
# start a realm
self.realm = RouterRealm(None, None, {'name': 'realm1'})
self.router_factory.start_realm(self.realm)
# allow everything
self.router = self.router_factory.get('realm1')
self.router.add_role(
RouterRoleStaticAuth(self.router,
'test_role',
default_permissions={
'uri': 'com.example.',
'match': 'prefix',
'allow': {
'call': True,
'register': True,
'publish': True,
'subscribe': True,
}
}))
# create a router session factory
self.session_factory = RouterSessionFactory(self.router_factory)
def setUp(self):
# create a router factory
self.router_factory = RouterFactory(None, None)
# start a realm
self.realm = RouterRealm(None, {u'name': u'realm1'})
self.router_factory.start_realm(self.realm)
# allow everything
self.router = self.router_factory.get(u'realm1')
self.router.add_role(
RouterRoleStaticAuth(self.router,
u'test_role',
default_permissions={
u'uri': u'com.myapp.',
u'match': u'prefix',
u'allow': {
u'call': True,
u'register': True,
u'publish': True,
u'subscribe': True,
}
}))
# create a router session factory
self.session_factory = RouterSessionFactory(self.router_factory)
def __init__(self, config=None, reactor=None, personality=None):
# base ctor
WorkerController.__init__(self,
config=config,
reactor=reactor,
personality=personality)
# factory for producing (per-realm) routers
self._router_factory = self.router_factory_class(None, self)
# factory for producing router sessions
self._router_session_factory = RouterSessionFactory(
self._router_factory)
# map: realm ID -> RouterRealm
self.realms = {}
# map: realm URI -> realm ID
self.realm_to_id = {}
# map: component ID -> RouterComponent
self.components = {}
# "global" shared between all components
self.components_shared = {u'reactor': reactor}
# map: transport ID -> RouterTransport
self.transports = {}
def __init__(self, config=None, reactor=None):
NativeWorkerSession.__init__(self, config, reactor)
# factory for producing (per-realm) routers
self._router_factory = RouterFactory()
# factory for producing router sessions
self._router_session_factory = RouterSessionFactory(self._router_factory)
# map: realm ID -> RouterRealm
self.realms = {}
# map: realm URI -> realm ID
self.realm_to_id = {}
# map: component ID -> RouterComponent
self.components = {}
# "global" shared between all components
self.components_shared = {
u'reactor': reactor
}
# map: transport ID -> RouterTransport
self.transports = {}
def setUp(self):
"""
Setup router and router session factories.
"""
# create a router factory
self.router_factory = RouterFactory(u'mynode')
# start a realm
self.router_factory.start_realm(RouterRealm(None, {u'name': u'realm1'}))
# 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
}
}
self.router = self.router_factory.get(u'realm1')
self.router.add_role(RouterRoleStaticAuth(self.router, u'test_role', default_permissions=default_permissions))
self.router.add_role(RouterRoleStaticAuth(self.router, None, default_permissions=default_permissions))
# create a router session factory
self.session_factory = RouterSessionFactory(self.router_factory)
def onJoin(self, details):
"""
Called when worker process has joined the node's management realm.
"""
yield NativeWorkerSession.onJoin(self, details, publish_ready=False)
# factory for producing (per-realm) routers
self._router_factory = RouterFactory(self._node_id)
# factory for producing router sessions
self._router_session_factory = RouterSessionFactory(self._router_factory)
# map: realm ID -> RouterRealm
self.realms = {}
# map: realm URI -> realm ID
self.realm_to_id = {}
# map: component ID -> RouterComponent
self.components = {}
# map: transport ID -> RouterTransport
self.transports = {}
# the procedures registered
procs = [
'get_router_realms',
'start_router_realm',
'stop_router_realm',
'get_router_realm_roles',
'start_router_realm_role',
'stop_router_realm_role',
'get_router_realm_uplinks',
'start_router_realm_uplink',
'stop_router_realm_uplink',
'get_router_components',
'start_router_component',
'stop_router_component',
'get_router_transports',
'start_router_transport',
'stop_router_transport',
]
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))
# NativeWorkerSession.publish_ready()
yield self.publish_ready()
def start_from_config(self, config):
controller_config = config.get('controller', {})
controller_options = controller_config.get('options', {})
controller_title = controller_options.get('title', 'crossbar-controller')
try:
import setproctitle
except ImportError:
log.msg("Warning, could not set process title (setproctitle not installed)")
else:
setproctitle.setproctitle(controller_title)
# the node's name (must be unique within the management realm)
if 'id' in controller_config:
self._node_id = controller_config['id']
else:
self._node_id = socket.gethostname()
# the node's management realm
self._realm = controller_config.get('realm', 'crossbar')
# the node controller singleton WAMP application session
#
# session_config = ComponentConfig(realm = options.realm, extra = options)
self._controller = NodeControllerSession(self)
# router and factory that creates router sessions
#
self._router_factory = RouterFactory(
options=RouterOptions(uri_check=RouterOptions.URI_CHECK_LOOSE),
debug=True)
self._router_session_factory = RouterSessionFactory(self._router_factory)
# add the node controller singleton session to the router
#
self._router_session_factory.add(self._controller)
# Detect WAMPlets
#
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
log.msg("Detected {} WAMPlets in environment:".format(len(wamplets)))
for wpl in wamplets:
log.msg("WAMPlet {}.{}".format(wpl['dist'], wpl['name']))
else:
log.msg("No WAMPlets detected in enviroment.")
self.run_node_config(config)
def make_router():
"""
Make a router, and return it and a RawSocket factory.
"""
# create a router factory
router_factory = RouterFactory(None)
# create a router session factory
session_factory = RouterSessionFactory(router_factory)
# Create a new RawSocket factory
rawsocket_server_factory = WampRawSocketServerFactory(session_factory, {})
# Create a new UniSocket factory
server_factory = UniSocketServerFactory(rawsocket_factory=rawsocket_server_factory)
return router_factory, server_factory, session_factory
def setUp(self):
"""
Setup router and router session factories.
"""
# create a router factory
self.router_factory = RouterFactory()
# start a realm
self.router_factory.start_realm(RouterRealm(None, {u'name': u'realm1'}))
# allow everything
permissions = RouterPermissions('', True, True, True, True, True)
router = self.router_factory.get(u'realm1')
router.add_role(RouterRoleStaticAuth(router, None, default_permissions=permissions))
# create a router session factory
self.session_factory = RouterSessionFactory(self.router_factory)
def make_router():
"""
Make a router, and return it and a RawSocket factory.
"""
# create a router factory
router_factory = RouterFactory(None, None)
# create a router session factory
session_factory = RouterSessionFactory(router_factory)
# Create a new WebSocket factory
websocket_server_factory = WampWebSocketServerFactory(session_factory, '.', {}, None)
# Create a new RawSocket factory
rawsocket_server_factory = WampRawSocketServerFactory(session_factory, {})
# Create a new UniSocket factory
server_factory = UniSocketServerFactory(websocket_factory_map={'/': websocket_server_factory},
rawsocket_factory=rawsocket_server_factory)
return router_factory, server_factory, session_factory
def start(self):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
if not self._config:
raise Exception("No node configuration set")
# get controller config/options
#
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
# 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._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)
panic = False
try:
# startup the node personality ..
yield self._startup()
# .. and notify systemd that we are fully up and running
try:
import sdnotify
sdnotify.SystemdNotifier().notify("READY=1")
except:
# do nothing on non-systemd platforms
pass
except ApplicationError as e:
panic = True
self.log.error("{msg}", msg=e.error_message())
except Exception:
panic = True
self.log.failure('Could not startup node: {log_failure.value}')
if panic:
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass
def start(self, cdc_mode=False):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
if not self._config:
raise Exception("No node configuration loaded")
if not cdc_mode and not self._config.get(
"controller", {}) and not self._config.get("workers", {}):
self.log.warn(
("You seem to have no controller config or workers, nor are "
"starting up in CDC mode. Check your config exists, or pass "
"--cdc to `crossbar start`."))
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass
return
# get controller config/options
#
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
# 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'))
# router and factory that creates router sessions
#
self._router_factory = RouterFactory()
self._router_session_factory = RouterSessionFactory(
self._router_factory)
# create a new router for the realm
#
rlm_config = {'name': self._realm}
rlm = RouterRealm(None, rlm_config)
router = self._router_factory.start_realm(rlm)
# always add a realm service session
#
cfg = ComponentConfig(self._realm)
rlm.session = RouterServiceSession(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
# add a router bridge session when running in managed mode
#
if cdc_mode:
self._bridge_session = NodeManagementBridgeSession(cfg)
self._router_session_factory.add(self._bridge_session,
authrole=u'trusted')
else:
self._bridge_session = None
# Node shutdown mode
#
if cdc_mode:
# in managed mode, a node - by default - only shuts down when explicitly asked to,
# or upon a fatal error in the node controller
self._node_shutdown_triggers = [
checkconfig.NODE_SHUTDOWN_ON_SHUTDOWN_REQUESTED
]
else:
# in standalone mode, a node - by default - is immediately shutting down whenever
# a worker exits (successfully or with error)
self._node_shutdown_triggers = [
checkconfig.NODE_SHUTDOWN_ON_WORKER_EXIT
]
# allow to override node shutdown triggers
#
if 'shutdown' in controller_options:
self.log.info(
"Overriding default node shutdown triggers with {triggers} from node config",
triggers=controller_options['shutdown'])
self._node_shutdown_triggers = controller_options['shutdown']
else:
self.log.info("Using default node shutdown triggers {triggers}",
triggers=self._node_shutdown_triggers)
# add the node controller singleton session
#
self._controller = NodeControllerSession(self)
self._router_session_factory.add(self._controller, authrole=u'trusted')
# detect WAMPlets (FIXME: remove this!)
#
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
self.log.info("Detected {wamplets} WAMPlets in environment:",
wamplets=len(wamplets))
for wpl in wamplets:
self.log.info("WAMPlet {dist}.{name}",
dist=wpl['dist'],
name=wpl['name'])
else:
self.log.debug("No WAMPlets detected in enviroment.")
panic = False
try:
# startup the node from local node configuration
#
yield self._startup(self._config)
# connect to CDC when running in managed mode
#
if cdc_mode:
cdc_config = controller_config.get(
'cdc',
{
# CDC connecting transport
u'transport': {
u'type': u'websocket',
u'url': u'wss://cdc.crossbario.com/ws',
u'endpoint': {
u'type': u'tcp',
u'host': u'cdc.crossbario.com',
u'port': 443,
u'timeout': 5,
u'tls': {
u'hostname': u'cdc.crossbario.com'
}
}
}
})
transport = cdc_config[u'transport']
hostname = None
if u'tls' in transport[u'endpoint']:
transport[u'endpoint'][u'tls'][u'hostname']
runner = ApplicationRunner(
url=transport['url'],
realm=None,
extra=None,
ssl=optionsForClientTLS(hostname) if hostname else None,
)
def make(config):
# extra info forwarded to CDC client session
extra = {
'node': self,
'on_ready': Deferred(),
'on_exit': Deferred(),
'node_key': self._node_key,
}
@inlineCallbacks
def on_ready(res):
self._manager, self._management_realm, self._node_id, self._node_extra = res
if self._bridge_session:
try:
yield self._bridge_session.attach_manager(
self._manager, self._management_realm,
self._node_id)
status = yield self._manager.call(
u'cdc.remote.status@1')
except:
self.log.failure()
else:
self.log.info(
'Connected to CDC for management realm "{realm}" (current time is {now})',
realm=self._management_realm,
now=status[u'now'])
else:
self.log.warn(
'Uplink CDC session established, but no bridge session setup!'
)
@inlineCallbacks
def on_exit(res):
if self._bridge_session:
try:
yield self._bridge_session.detach_manager()
except:
self.log.failure()
else:
self.log.info(
'Disconnected from CDC for management realm "{realm}"',
realm=self._management_realm)
else:
self.log.warn(
'Uplink CDC session lost, but no bridge session setup!'
)
self._manager, self._management_realm, self._node_id, self._node_extra = None, None, None, None
extra['on_ready'].addCallback(on_ready)
extra['on_exit'].addCallback(on_exit)
config = ComponentConfig(extra=extra)
session = NodeManagementSession(config)
return session
self.log.info("Connecting to CDC at '{url}' ..",
url=transport[u'url'])
yield runner.run(make,
start_reactor=False,
auto_reconnect=True)
# Notify systemd that crossbar is fully up and running
# (this has no effect on non-systemd platforms)
try:
import sdnotify
sdnotify.SystemdNotifier().notify("READY=1")
except:
pass
except ApplicationError as e:
panic = True
self.log.error("{msg}", msg=e.error_message())
except Exception:
panic = True
traceback.print_exc()
if panic:
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass
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, cdc_mode=False):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
if not self._config:
raise Exception("No node configuration loaded")
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
# 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'))
# the node controller realm
#
self._realm = controller_config.get('realm', 'crossbar')
# the node's name (must be unique within the management realm when running
# in "managed mode")
#
if 'id' in controller_config:
self._node_id = controller_config['id']
self.log.info("Node ID '{node_id}' set from config",
node_id=self._node_id)
elif 'CDC_ID' in os.environ:
self._node_id = u'{}'.format(os.environ['CDC_ID'])
self.log.info(
"Node ID '{node_id}' set from environment variable CDC_ID",
node_id=self._node_id)
else:
self._node_id = u'{}'.format(socket.gethostname())
self.log.info("Node ID '{node_id}' set from hostname",
node_id=self._node_id)
# standalone vs managed mode
#
if 'cdc' in controller_config and controller_config['cdc'].get(
'enabled', False):
self._prepare_node_keys()
cdc_config = controller_config['cdc']
# CDC connecting transport
#
if 'transport' in cdc_config:
transport = cdc_config['transport']
if 'tls' in transport['endpoint']:
hostname = transport['endpoint']['tls']['hostname']
else:
raise Exception(
"TLS activated on CDC connection, but 'hostname' not provided"
)
self.log.warn(
"CDC transport configuration overridden from node config!")
else:
transport = {
"type": u"websocket",
"url": u"wss://devops.crossbario.com/ws",
"endpoint": {
"type": u"tcp",
"host": u"devops.crossbario.com",
"port": 443,
"timeout": 5,
"tls": {
"hostname": u"devops.crossbario.com"
}
}
}
hostname = u'devops.crossbario.com'
# CDC management realm
#
if 'realm' in cdc_config:
realm = cdc_config['realm']
self.log.info("CDC management realm '{realm}' set from config",
realm=realm)
elif 'CDC_REALM' in os.environ:
realm = u"{}".format(os.environ['CDC_REALM']).strip()
self.log.info(
"CDC management realm '{realm}' set from enviroment variable CDC_REALM",
realm=realm)
else:
raise Exception(
"CDC management realm not set - either 'realm' must be set in node configuration, or in CDC_REALM enviroment variable"
)
# CDC authentication credentials (for WAMP-CRA)
#
authid = self._node_id
if 'secret' in cdc_config:
authkey = cdc_config['secret']
self.log.info("CDC authentication secret loaded from config")
elif 'CDC_SECRET' in os.environ:
authkey = u"{}".format(os.environ['CDC_SECRET']).strip()
self.log.info(
"CDC authentication secret loaded from environment variable CDC_SECRET"
)
else:
raise Exception(
"CDC authentication secret not set - either 'secret' must be set in node configuration, or in CDC_SECRET enviroment variable"
)
# extra info forwarded to CDC client session
#
extra = {
'node': self,
'onready': Deferred(),
'onexit': Deferred(),
'authid': authid,
'authkey': authkey
}
runner = ApplicationRunner(
url=transport['url'],
realm=realm,
extra=extra,
ssl=optionsForClientTLS(hostname),
debug=False,
debug_wamp=False,
)
try:
self.log.info("Connecting to CDC at '{url}' ..",
url=transport['url'])
yield runner.run(NodeManagementSession, start_reactor=False)
# wait until we have attached to the uplink CDC
self._manager = yield extra['onready']
except Exception as e:
raise Exception("Could not connect to CDC - {}".format(e))
# in managed mode, a node - by default - only shuts down when explicitly asked to,
# or upon a fatal error in the node controller
self._node_shutdown_triggers = [
checkconfig.NODE_SHUTDOWN_ON_SHUTDOWN_REQUESTED
]
self.log.info(
"Connected to Crossbar.io DevOps Center (CDC)! Your node runs in managed mode."
)
else:
self._manager = None
# in standalone mode, a node - by default - is immediately shutting down whenever
# a worker exits (successfully or with error)
self._node_shutdown_triggers = [
checkconfig.NODE_SHUTDOWN_ON_WORKER_EXIT
]
# allow to override node shutdown triggers
#
if 'shutdown' in controller_options:
self.log.info(
"Overriding default node shutdown triggers with {} from node config"
.format(controller_options['shutdown']))
self._node_shutdown_triggers = controller_options['shutdown']
else:
self.log.info("Using default node shutdown triggers {}".format(
self._node_shutdown_triggers))
# router and factory that creates router sessions
#
self._router_factory = RouterFactory(self._node_id)
self._router_session_factory = RouterSessionFactory(
self._router_factory)
rlm_config = {'name': self._realm}
rlm = RouterRealm(None, rlm_config)
# create a new router for the realm
router = self._router_factory.start_realm(rlm)
# add a router/realm service session
cfg = ComponentConfig(self._realm)
rlm.session = RouterServiceSession(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
if self._manager:
self._bridge_session = NodeManagementBridgeSession(
cfg, self, self._manager)
self._router_session_factory.add(self._bridge_session,
authrole=u'trusted')
else:
self._bridge_session = None
# the node controller singleton WAMP application session
#
self._controller = NodeControllerSession(self)
# add the node controller singleton session to the router
#
self._router_session_factory.add(self._controller, authrole=u'trusted')
# Detect WAMPlets
#
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
self.log.info("Detected {wamplets} WAMPlets in environment:",
wamplets=len(wamplets))
for wpl in wamplets:
self.log.info("WAMPlet {dist}.{name}",
dist=wpl['dist'],
name=wpl['name'])
else:
self.log.debug("No WAMPlets detected in enviroment.")
panic = False
try:
yield self._startup(self._config)
except ApplicationError as e:
panic = True
self.log.error("{msg}", msg=e.error_message())
except Exception:
panic = True
traceback.print_exc()
if panic:
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass
def onJoin(self, details):
"""
Called when worker process has joined the node's management realm.
"""
yield NativeWorkerSession.onJoin(self, details, publish_ready=False)
# Jinja2 templates for Web (like WS status page et al)
#
templates_dir = os.path.abspath(
pkg_resources.resource_filename("crossbar", "web/templates"))
if self.debug:
log.msg("Using Web templates from {}".format(templates_dir))
self._templates = jinja2.Environment(
loader=jinja2.FileSystemLoader(templates_dir))
# factory for producing (per-realm) routers
self._router_factory = RouterFactory()
# factory for producing router sessions
self._router_session_factory = RouterSessionFactory(
self._router_factory)
# map: realm ID -> RouterRealm
self.realms = {}
# map: realm URI -> realm ID
self.realm_to_id = {}
# map: transport ID -> RouterTransport
self.transports = {}
# map: link ID -> RouterLink
self.links = {}
# map: component ID -> RouterComponent
self.components = {}
# the procedures registered
procs = [
'get_router_realms', 'start_router_realm', 'stop_router_realm',
'get_router_realm_roles', 'start_router_realm_role',
'stop_router_realm_role', 'get_router_components',
'start_router_component', 'stop_router_component',
'get_router_transports', 'start_router_transport',
'stop_router_transport', 'get_router_links', 'start_router_link',
'stop_router_link'
]
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))
# NativeWorkerSession.publish_ready()
yield self.publish_ready()
def setUp(self):
"""
Setup router and router session factories.
"""
self.router_factory = RouterFactory()
self.session_factory = RouterSessionFactory(self.router_factory)
def start(self):
"""
Starts this node. This will start a node controller and then spawn new worker
processes as needed.
"""
if not self._config:
self.check_config()
controller_config = self._config.get('controller', {})
controller_options = controller_config.get('options', {})
controller_title = controller_options.get('title',
'crossbar-controller')
try:
import setproctitle
except ImportError:
self.log.warn(
"Warning, could not set process title (setproctitle not installed)"
)
else:
setproctitle.setproctitle(controller_title)
# the node's name (must be unique within the management realm)
if 'id' in controller_config:
self._node_id = controller_config['id']
else:
self._node_id = socket.gethostname()
if 'manager' in controller_config:
extra = {
'onready': Deferred(),
# authentication information for connecting to uplinkg CDC router
# using WAMP-CRA authentication
#
'authid': self._node_id,
'authkey': controller_config['manager']['key']
}
realm = controller_config['manager']['realm']
transport = controller_config['manager']['transport']
runner = ApplicationRunner(url=transport['url'],
realm=realm,
extra=extra,
debug_wamp=False)
runner.run(NodeManagementSession, start_reactor=False)
# wait until we have attached to the uplink CDC
self._management_session = yield extra['onready']
self.log.info(
"Node is connected to Crossbar.io DevOps Center (CDC)")
else:
self._management_session = None
# the node's management realm
self._realm = controller_config.get('realm', 'crossbar')
# router and factory that creates router sessions
#
self._router_factory = RouterFactory()
self._router_session_factory = RouterSessionFactory(
self._router_factory)
rlm = RouterRealm(None, {'name': self._realm})
# create a new router for the realm
router = self._router_factory.start_realm(rlm)
# add a router/realm service session
cfg = ComponentConfig(self._realm)
rlm.session = RouterServiceSession(cfg, router)
self._router_session_factory.add(rlm.session, authrole=u'trusted')
if self._management_session:
self._bridge_session = NodeManagementBridgeSession(
cfg, self._management_session)
self._router_session_factory.add(self._bridge_session,
authrole=u'trusted')
else:
self._bridge_session = None
# the node controller singleton WAMP application session
#
self._controller = NodeControllerSession(self)
# add the node controller singleton session to the router
#
self._router_session_factory.add(self._controller, authrole=u'trusted')
# Detect WAMPlets
#
wamplets = self._controller._get_wamplets()
if len(wamplets) > 0:
self.log.info("Detected {wamplets} WAMPlets in environment:",
wamplets=len(wamplets))
for wpl in wamplets:
self.log.info("WAMPlet {dist}.{name}",
dist=wpl['dist'],
name=wpl['name'])
else:
self.log.info("No WAMPlets detected in enviroment.")
panic = False
try:
yield self._startup(self._config)
except ApplicationError as e:
panic = True
for line in e.args[0].strip().splitlines():
self.log.error(line)
except Exception:
panic = True
traceback.print_exc()
if panic:
try:
self._reactor.stop()
except twisted.internet.error.ReactorNotRunning:
pass
