def __init__(self, config, templates):
"""
Ctor.
:param factory: WAMP session factory.
:type factory: An instance of ..
:param config: Crossbar transport configuration.
:type config: dict
"""
options = config.get('options', {})
server = "Crossbar/{}".format(crossbar.__version__)
externalPort = options.get('external_port', None)
WebSocketServerFactory.__init__(self,
url = config.get('url', None),
server = server,
externalPort = externalPort,
debug = config.get('debug', False))
## transport configuration
self._config = config
## Jinja2 templates for 404 etc
self._templates = templates
## set WebSocket options
set_websocket_options(self, options)
def __init__(self, config, templates):
"""
:param config: Crossbar transport configuration.
:type config: dict
"""
options = config.get("options", {})
server = "Crossbar/{}".format(crossbar.__version__)
externalPort = options.get("external_port", None)
WebSocketServerFactory.__init__(
self,
url=config.get("url", None),
server=server,
externalPort=externalPort,
debug=config.get("debug", False),
)
# transport configuration
self._config = config
# Jinja2 templates for 404 etc
self._templates = templates
# set WebSocket options
set_websocket_options(self, options)
def __init__(self, config, templates):
"""
Ctor.
:param factory: WAMP session factory.
:type factory: An instance of ..
:param config: Crossbar transport configuration.
:type config: dict
"""
options = config.get('options', {})
server = "Crossbar/{}".format(crossbar.__version__)
externalPort = options.get('external_port', None)
WebSocketServerFactory.__init__(self,
url=config.get('url', None),
server=server,
externalPort=externalPort,
debug=config.get('debug', False))
## transport configuration
self._config = config
## Jinja2 templates for 404 etc
self._templates = templates
## set WebSocket options
set_websocket_options(self, options)
def __init__(self, config, templates):
"""
:param config: Crossbar transport configuration.
:type config: dict
"""
options = config.get('options', {})
server = "Crossbar/{}".format(crossbar.__version__)
externalPort = options.get('external_port', None)
WebSocketServerFactory.__init__(self, url=config.get('url', None), server=server, externalPort=externalPort)
# transport configuration
self._config = config
# Jinja2 templates for 404 etc
self._templates = templates
# set WebSocket options
set_websocket_options(self, options)
def start_component(self,
component_id,
config,
reload_modules=False,
details=None):
"""
Starts a component in this container worker.
:param component_id: The ID under which to start the component.
:type component_id: str
:param config: Component configuration.
:type config: dict
:param reload_modules: If `True`, enforce reloading of modules (user code)
that were modified (see: TrackingModuleReloader).
:type reload_modules: bool
:param details: Caller details.
:type details: instance of :class:`autobahn.wamp.types.CallDetails`
:returns: Component startup information.
:rtype: dict
"""
self.log.debug(u'{klass}.start_component({component_id}, {config})',
klass=self.__class__.__name__,
component_id=component_id,
config=config)
# prohibit starting a component twice
#
if component_id in self.components:
emsg = u'duplicate component "{}" - a component with this ID is already running (or starting)'.format(
component_id)
self.log.debug(emsg)
raise ApplicationError(u'crossbar.error.already_running', emsg)
# check component configuration
#
try:
self.personality.check_container_component(self.personality,
config)
except Exception as e:
emsg = u'invalid container component configuration: {}'.format(e)
self.log.debug(emsg)
raise ApplicationError(u'crossbar.error.invalid_configuration',
emsg)
else:
self.log.debug(u'starting component "{component_id}" ..',
component_id=component_id)
# WAMP application component factory
#
realm = config.get(u'realm', None)
assert type(realm) == str
extra = config.get(u'extra', {})
assert type(extra) == dict
# forward crossbar node base directory
extra['cbdir'] = self.config.extra.cbdir
# allow access to controller session
controller = self if self.config.extra.expose_controller else None
# expose an object shared between components
shared = self.components_shared if self.config.extra.expose_shared else None
# this is the component configuration provided to the components ApplicationSession
component_config = ComponentConfig(realm=realm,
extra=extra,
keyring=None,
controller=controller,
shared=shared)
# define component ctor function
try:
create_component = _appsession_loader(config)
except ApplicationError as e:
# for convenience, also log failed component loading
self.log.error(u'component loading failed', log_failure=Failure())
if u'No module named' in str(e):
self.log.error(u' Python module search paths:')
for path in e.kwargs['pythonpath']:
self.log.error(u' {path}', path=path)
raise
# force reload of modules (user code)
#
if reload_modules:
self._module_tracker.reload()
# prepare some cleanup code in case this connection goes away
def _closed(session, was_clean):
"""
This is moderate hack around the fact that we don't have any way
to "listen" for a close event on websocket or rawsocket
objects. Also, the rawsocket implementation doesn't have
"a" function we can wrap anyway (they are asyncio vs
Twisted specific), so for both WebSocket and rawsocket
cases, we actually listen on the WAMP session for
transport close notifications.
Ideally we'd listen for "close" on the transport but this
works fine for cleaning up the components.
"""
if component_id not in self.components:
self.log.warn(
"Component '{id}' closed, but not in set.",
id=component_id,
)
return
if was_clean:
self.log.info(
"Closed connection to '{id}'",
id=component_id,
)
else:
self.log.error(
"Lost connection to component '{id}' uncleanly",
id=component_id,
)
component = self.components[component_id]
del self.components[component_id]
self._publish_component_stop(component)
component._stopped.callback(component.marshal())
del component
# figure out if we need to shut down the container itself or not
if not was_clean and self._exit_mode == self.SHUTDOWN_ON_ANY_COMPONENT_FAILED:
self.log.info(
"A component has failed: stopping container in exit mode <{exit_mode}> ...",
exit_mode=self._exit_mode,
)
self.shutdown()
return
if self._exit_mode == self.SHUTDOWN_ON_ANY_COMPONENT_STOPPED:
self.log.info(
"A component has stopped: stopping container in exit mode <{exit_mode}> ...",
exit_mode=self._exit_mode,
)
self.shutdown()
return
if not self.components:
if self._exit_mode == self.SHUTDOWN_ON_LAST_COMPONENT_STOPPED:
self.log.info(
"Container is hosting no more components: stopping container in exit mode <{exit_mode}> ...",
exit_mode=self._exit_mode,
)
self.shutdown()
return
else:
self.log.info(
"Container is hosting no more components: continue running in exit mode <{exit_mode}>",
exit_mode=self._exit_mode,
)
else:
self.log.info(
"Container is still hosting {component_count} components: continue running in exit mode <{exit_mode}>",
exit_mode=self._exit_mode,
component_count=len(self.components),
)
# determine if we should re-start the component. Note that
# we can only arrive here if we *didn't* decide to
# shutdown above .. so if we have a shutdown mode of
# SHUTDOWN_ON_ANY_COMPONENT_STOPPED will mean we never try
# to re-start anything.
if self._restart_mode and self._restart_mode != self.RESTART_NEVER:
def restart_component():
# Think: if this below start_component() fails,
# we'll still schedule *exactly one* new re-start
# attempt for it, right?
self.log.info(
"Restarting component '{component_id}'",
component_id=component_id,
)
return self.start_component(
component_id,
config,
reload_modules=reload_modules,
details=details,
)
# note we must yield to the reactor with
# callLater(0, ..) to avoid infinite recurision if
# we're stuck in a restart loop
from twisted.internet import reactor
if self._restart_mode == self.RESTART_ALWAYS:
reactor.callLater(0, restart_component)
elif self._restart_mode == self.RESTART_FAILED and not was_clean:
reactor.callLater(0, restart_component)
joined_d = Deferred()
# WAMP application session factory
#
def create_session():
try:
session = create_component(component_config)
# any exception spilling out from user code in onXXX handlers is fatal!
def panic(fail, msg):
self.log.error(
"Fatal error in component: {msg} - {log_failure.value}",
msg=msg,
log_failure=fail,
)
session.disconnect()
session._swallow_error = panic
# see note above, for _closed -- we should be
# listening for "the transport was closed", but
# "session disconnect" is close enough (since there
# are no "proper events" from websocket/rawsocket
# implementations).
session.on('disconnect', _closed)
# note, "ready" here means: onJoin and any on('join',
# ..) handlers have all completed successfully. This
# is necessary for container-components (as opposed to
# router-components) to work as expected
def _ready(s):
joined_d.callback(None)
session.on('ready', _ready)
def _left(s, details):
if not joined_d.called:
joined_d.errback(
ApplicationError(
details.reason,
details.message,
))
session.on('leave', _left)
return session
except Exception:
self.log.failure(
u'component instantiation failed: {log_failure.value}')
raise
# WAMP transport factory
#
transport_config = config[u'transport']
if transport_config[u'type'] == u'websocket':
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(
create_session, transport_config[u'url'])
transport_factory.noisy = False
if 'options' in transport_config:
set_websocket_options(transport_factory,
transport_config['options'])
elif transport_config[u'type'] == u'rawsocket':
transport_factory = WampRawSocketClientFactory(
create_session, transport_config)
transport_factory.noisy = False
if 'options' in transport_config:
set_rawsocket_options(transport_factory,
transport_config['options'])
else:
# should not arrive here, since we did check the config before
raise Exception(u'logic error')
# create and connect client endpoint
#
endpoint = create_connecting_endpoint_from_config(
transport_config[u'endpoint'], self.config.extra.cbdir,
self._reactor, self.log)
# now, actually connect the client
#
d = endpoint.connect(transport_factory)
def on_connect_success(proto):
component = ContainerComponent(component_id, config, proto, None)
self.components[component_id] = component
# publish event "on_component_start" to all but the caller
#
uri = self._uri_prefix + u'.on_component_started'
component_started = {u'id': component_id, u'config': config}
self.publish(uri,
component_started,
options=PublishOptions(exclude=details.caller))
return component_started
def on_connect_error(err):
# https://twistedmatrix.com/documents/current/api/twisted.internet.error.ConnectError.html
if isinstance(err.value, internet.error.ConnectError):
emsg = u'could not connect container component to router - transport establishment failed ({})'.format(
err.value)
self.log.warn(emsg)
raise ApplicationError(u'crossbar.error.cannot_connect', emsg)
else:
# should not arrive here (since all errors arriving here
# should be subclasses of ConnectError)
raise err
def await_join(arg):
"""
We don't want to consider this component working until its on_join
has completed (see create_session() above where this is hooked up)
"""
return joined_d
d.addCallbacks(on_connect_success, on_connect_error)
d.addCallback(await_join)
return d
