def getMapUpdaterComponentService(self, url, realm, mapUpdater):
def create(config):
try:
session = MapUpdaterComponent(mapUpdater, config)
except Exception as e:
# the app component could not be created .. fatal
print(e)
else:
session.debug_app = True
return session
sessionFactory = ApplicationSessionFactory(
ComponentConfig(realm, None))
sessionFactory.session = create
transportFactory = WampWebSocketClientFactory(
sessionFactory, url=url)
transportFactory.noisy = False
transportFactory.autoPingInterval = 30
transportFactory.autoPingTimeout = 30
isSecure, host, port, resource, path, params = parseWsUrl(url)
endpoint = HostnameEndpoint(reactor, host.encode('utf8'), port)
if isSecure:
contextFactory = optionsForClientTLS(hostname=host)
endpoint = wrapClientTLS(contextFactory, endpoint)
return ClientService(endpoint, transportFactory)
def __init__(self, *args, **kwargs):
self.log.debug('{func}(*args={_args}, **kwargs={_kwargs})',
_args=args,
_kwargs=kwargs,
func=hltype(NativeWorkerClientFactory.__init__))
self._authrole = kwargs.pop('authrole')
WampWebSocketClientFactory.__init__(self, *args, **kwargs)
self.proto = None
def __init2__(self, factory, config):
## transport configuration
self._config = config
WampWebSocketClientFactory.__init__(self, config)
self.setProtocolOptions(failByDrop = False)
def __init2__(self, factory, config):
## transport configuration
self._config = config
WampWebSocketClientFactory.__init__(self, config)
self.setProtocolOptions(failByDrop=False)
def start(self):
"""
Starts this node. This will start a node controller
and then spawn new worker processes as needed.
The node controller will watch spawned processes,
communicate via stdio with the worker, and start
and restart the worker processes as needed.
"""
## the node controller singleton WAMP application session
##
self._node_controller_session = NodeControllerSession(self)
## router and factory that creates router sessions
##
self._router_factory = RouterFactory()
self._router_session_factory = RouterSessionFactory(self._router_factory)
## add the node controller singleton session to the router
##
self._router_session_factory.add(self._node_controller_session)
if True:
## create a WAMP-over-WebSocket transport server factory
##
from autobahn.twisted.websocket import WampWebSocketServerFactory
from twisted.internet.endpoints import serverFromString
self._router_server_transport_factory = WampWebSocketServerFactory(self._router_session_factory, "ws://localhost:9000", debug = False)
self._router_server_transport_factory.setProtocolOptions(failByDrop = False)
## start the WebSocket server from an endpoint
##
self._router_server = serverFromString(self._reactor, "tcp:9000")
self._router_server.listen(self._router_server_transport_factory)
## factory that creates router session transports. these are for clients
## that talk WAMP-WebSocket over pipes with spawned worker processes and
## for any uplink session to a management service
##
self._router_client_transport_factory = WampWebSocketClientFactory(self._router_session_factory, "ws://localhost", debug = False)
self._router_client_transport_factory.setProtocolOptions(failByDrop = False)
if False:
management_session_factory = ApplicationSessionFactory()
management_session_factory.session = NodeManagementSession
management_session_factory.node_controller_session = node_controller_session
management_transport_factory = WampWebSocketClientFactory(management_session_factory, "ws://127.0.0.1:7000")
management_transport_factory.setProtocolOptions(failByDrop = False)
management_client = clientFromString(self._reactor, "tcp:127.0.0.1:7000")
management_client.connect(management_transport_factory)
## startup the node from configuration file
##
self._node_controller_session.run_node_config(self._config)
def start_remote_management_client(self):
from crossbar.management import NodeManagementSession
management_session_factory = ApplicationSessionFactory()
management_session_factory.session = NodeManagementSession
management_session_factory.node_controller_session = node_controller_session
management_transport_factory = WampWebSocketClientFactory(management_session_factory, "ws://127.0.0.1:7000")
management_transport_factory.setProtocolOptions(failByDrop = False)
management_client = clientFromString(self._reactor, "tcp:127.0.0.1:7000")
management_client.connect(management_transport_factory)
def __init__(self, config, *args, **kwargs):
global _transportFactory
WampWebSocketClientFactory.__init__(self, *args, **kwargs)
try:
protocolOptions = config.extra.get('protocolOptions', None)
if protocolOptions:
self.setProtocolOptions(**protocolOptions)
_transportFactory = self
except Exception as e:
print(_("Custom protocol options failed :"), e)
_transportFactory = None
def RegisterWampClient():
## start logging to console
# log.startLogging(sys.stdout)
# create a WAMP application session factory
component_config = types.ComponentConfig(
realm = realm,
extra = {"ID":ID})
session_factory = wamp.ApplicationSessionFactory(
config = component_config)
session_factory.session = WampSession
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(
session_factory,
url = url,
serializers = [MsgPackSerializer()],
debug = False,
debug_wamp = False)
# start the client from a Twisted endpoint
conn = connectWS(transport_factory)
confnodesroot.logger.write(_("WAMP connecting to URL : %s\n")%url)
return conn
def _create_transport_factory(reactor, transport, session_factory):
"""
Create a WAMP-over-XXX transport factory.
"""
if transport.type == u'websocket':
serializers = create_transport_serializers(transport)
factory = WampWebSocketClientFactory(session_factory,
url=transport.url,
serializers=serializers)
elif transport.type == u'rawsocket':
serializer = create_transport_serializer(transport.serializers[0])
factory = WampRawSocketClientFactory(session_factory,
serializer=serializer)
else:
assert (False), 'should not arrive here'
# set the options one at a time so we can give user better feedback
for k, v in transport.options.items():
try:
factory.setProtocolOptions(**{k: v})
except (TypeError, KeyError):
# this allows us to document options as snake_case
# until everything internally is upgraded from
# camelCase
try:
factory.setProtocolOptions(
**{_camel_case_from_snake_case(k): v})
except (TypeError, KeyError):
raise ValueError("Unknown {} transport option: {}={}".format(
transport.type, k, v))
return factory
def connect(self, ip, port, realm):
self._realm = realm
self._url = 'ws://' + ip + ':' + port + '/ws'
self._reactor_thread = None
self._session_factoryWriter = None
self._session_factoryReader = None
cfgReader = ComponentConfig(self._realm, self._extra)
cfgWriter = ComponentConfig(self._realm, self._extra)
self._session_factoryReader = ApplicationSessionFactory(cfgReader)
self._session_factoryReader.session = ClientReader
self._session_factoryWriter = ApplicationSessionFactory(cfgWriter)
self._session_factoryWriter.session = ClientWriter
self._factoryReader = WampWebSocketClientFactory(
self._session_factoryReader,
url=self._url,
# debug = self._debug, debug_wamp = self._debug_wamp
)
self._factoryWriter = WampWebSocketClientFactory(
self._session_factoryWriter,
url=self._url,
# debug = self._debug, debug_wamp = self._debug_wamp
)
self._reactor_thread = threading.Thread(target=reactor.run,
args=(False, ))
self._reactor_thread.daemon = True
endpoint_descriptor = 'tcp:' + ip + ':' + port
self._clientReader = clientFromString(reactor, endpoint_descriptor)
self._clientReader.connect(self._factoryReader)
self._clientWriter = clientFromString(reactor, endpoint_descriptor)
self._clientWriter.connect(self._factoryWriter)
self._reactor_thread.start()
return self
def run(self, make):
"""
Run the application component.
:param make: A factory that produces instances of :class:`autobahn.asyncio.wamp.ApplicationSession`
when called with an instance of :class:`autobahn.wamp.types.ComponentConfig`.
:type make: callable
"""
is_secure, host, port, resource, path, params = parse_url(self.url)
# start logging to console
if self.debug or self.debug_wamp or self.debug_app:
pass
# log.startLogging(sys.stdout)
# factory for use ApplicationSession
def create():
"""
Will trying to create an ApplicationSession object
:return: ApplicationSession
"""
cfg = ComponentConfig(self.realm, self.extra)
try:
session = make(config=cfg)
except Exception as e:
# the app component could not be created .. fatal
self.logger.critical('CREATE RUNNER EXCEPTION {}'.format(
e.message))
else:
session.debug_app = self.debug_app
return session
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(create, url=self.url)
if is_secure:
endpoint_descriptor = "ssl:{0}:{1}".format(host, port)
else:
endpoint_descriptor = "tcp:{0}:{1}".format(host, port)
try:
self.logger.info(
'Trying to connect to: {}'.format(endpoint_descriptor))
self.connect(endpoint_descriptor, transport_factory, make)
return self
except Exception as e:
self.logger.error('CLIENT CONNECT ERROR: {}'.format(e.message))
def _create_transport_factory(reactor, transport, session_factory):
"""
Create a WAMP-over-XXX transport factory.
"""
if transport.type == u'websocket':
serializers = _create_transport_serializers(transport)
factory = WampWebSocketClientFactory(session_factory, url=transport.url, serializers=serializers)
elif transport.type == u'rawsocket':
serializer = _create_transport_serializer(transport.serializers[0])
factory = WampRawSocketClientFactory(session_factory, serializer=serializer)
else:
assert(False), 'should not arrive here'
# set the options one at a time so we can give user better feedback
for k, v in transport.options.items():
try:
factory.setProtocolOptions(**{k: v})
except (TypeError, KeyError):
# this allows us to document options as snake_case
# until everything internally is upgraded from
# camelCase
try:
factory.setProtocolOptions(
**{_camel_case_from_snake_case(k): v}
)
except (TypeError, KeyError):
raise ValueError(
"Unknown {} transport option: {}={}".format(transport.type, k, v)
)
return factory
def _create_transport_factory(reactor, transport, session_factory):
"""
Create a WAMP-over-XXX transport factory.
"""
if transport.type == 'websocket':
# FIXME: forward WebSocket options
serializers = _create_transport_serializers(transport)
return WampWebSocketClientFactory(session_factory, url=transport.url, serializers=serializers)
elif transport.type == 'rawsocket':
# FIXME: forward RawSocket options
serializer = _create_transport_serializer(transport.serializer)
return WampRawSocketClientFactory(session_factory, serializer=serializer)
else:
assert(False), 'should not arrive here'
def _create_transport_factory(reactor, transport_config, session_factory):
"""
Create a WAMP-over-XXX transport factory.
"""
if transport_config['type'] == 'websocket':
# FIXME: forward WebSocket options
serializers = _create_transport_serializers(transport_config)
return WampWebSocketClientFactory(session_factory, url=transport_config['url'], serializers=serializers)
elif transport_config['type'] == 'rawsocket':
# FIXME: forward RawSocket options
serializer = _create_transport_serializer(transport_config.get('serializer', u'json'))
return WampRawSocketClientFactory(session_factory, serializer=serializer)
else:
assert(False), 'should not arrive here'
def run(self, make, start_reactor=True):
"""
Run the application component.
:param make: A factory that produces instances of :class:`autobahn.asyncio.wamp.ApplicationSession`
when called with an instance of :class:`autobahn.wamp.types.ComponentConfig`.
:type make: callable
"""
from twisted.internet import reactor
isSecure, host, port, resource, path, params = parseWsUrl(self.url)
## start logging to console
if self.debug or self.debug_wamp or self.debug_app:
log.startLogging(sys.stdout)
## factory for use ApplicationSession
def create():
cfg = ComponentConfig(self.realm, self.extra)
try:
session = make(cfg)
except Exception:
## the app component could not be created .. fatal
log.err()
reactor.stop()
else:
session.debug_app = self.debug_app
return session
## create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(
create, url=self.url, debug=self.debug, debug_wamp=self.debug_wamp)
## start the client from a Twisted endpoint
from twisted.internet.endpoints import clientFromString
if isSecure:
endpoint_descriptor = "ssl:{0}:{1}".format(host, port)
else:
endpoint_descriptor = "tcp:{0}:{1}".format(host, port)
client = clientFromString(reactor, endpoint_descriptor)
client.connect(transport_factory)
## now enter the Twisted reactor loop
if start_reactor:
reactor.run()
def run(self, make, start_reactor=True):
"""
Run the application component.
:param make: A factory that produces instances of :class:`autobahn.asyncio.wamp.ApplicationSession`
when called with an instance of :class:`autobahn.wamp.types.ComponentConfig`.
:type make: callable
:param start_reactor: if True (the default) this method starts
the Twisted reactor and doesn't return until the reactor
stops. If there are any problems starting the reactor or
connect()-ing, we stop the reactor and raise the exception
back to the caller.
:returns: None is returned, unless you specify
``start_reactor=False`` in which case the Deferred that
connect() returns is returned; this will callback() with
an IProtocol instance, which will actually be an instance
of :class:`WampWebSocketClientProtocol`
"""
if start_reactor:
# only select framework, set loop and start logging when we are asked
# start the reactor - otherwise we are running in a program that likely
# already tool care of all this.
from twisted.internet import reactor
txaio.use_twisted()
txaio.config.loop = reactor
if self.debug or self.debug_app:
txaio.start_logging(level='debug')
else:
txaio.start_logging(level='info')
isSecure, host, port, resource, path, params = parseWsUrl(self.url)
# factory for use ApplicationSession
def create():
cfg = ComponentConfig(self.realm, self.extra)
try:
session = make(cfg)
except Exception as e:
if start_reactor:
# the app component could not be created .. fatal
self.log.error(str(e))
reactor.stop()
else:
# if we didn't start the reactor, it's up to the
# caller to deal with errors
raise
else:
session.debug_app = self.debug_app
return session
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(create, url=self.url, serializers=self.serializers,
proxy=self.proxy, debug=self.debug)
# supress pointless log noise like
# "Starting factory <autobahn.twisted.websocket.WampWebSocketClientFactory object at 0x2b737b480e10>""
transport_factory.noisy = False
# if user passed ssl= but isn't using isSecure, we'll never
# use the ssl argument which makes no sense.
context_factory = None
if self.ssl is not None:
if not isSecure:
raise RuntimeError(
'ssl= argument value passed to %s conflicts with the "ws:" '
'prefix of the url argument. Did you mean to use "wss:"?' %
self.__class__.__name__)
context_factory = self.ssl
elif isSecure:
from twisted.internet.ssl import optionsForClientTLS
context_factory = optionsForClientTLS(host)
from twisted.internet import reactor
if self.proxy is not None:
from twisted.internet.endpoints import TCP4ClientEndpoint
client = TCP4ClientEndpoint(reactor, self.proxy['host'], self.proxy['port'])
transport_factory.contextFactory = context_factory
elif isSecure:
from twisted.internet.endpoints import SSL4ClientEndpoint
assert context_factory is not None
client = SSL4ClientEndpoint(reactor, host, port, context_factory)
else:
from twisted.internet.endpoints import TCP4ClientEndpoint
client = TCP4ClientEndpoint(reactor, host, port)
d = client.connect(transport_factory)
# as the reactor shuts down, we wish to wait until we've sent
# out our "Goodbye" message; leave() returns a Deferred that
# fires when the transport gets to STATE_CLOSED
def cleanup(proto):
if hasattr(proto, '_session') and proto._session is not None:
if proto._session.is_attached():
return proto._session.leave()
elif proto._session.is_connected():
return proto._session.disconnect()
# when our proto was created and connected, make sure it's cleaned
# up properly later on when the reactor shuts down for whatever reason
def init_proto(proto):
reactor.addSystemEventTrigger('before', 'shutdown', cleanup, proto)
return proto
# if we connect successfully, the arg is a WampWebSocketClientProtocol
d.addCallback(init_proto)
# if the user didn't ask us to start the reactor, then they
# get to deal with any connect errors themselves.
if start_reactor:
# if an error happens in the connect(), we save the underlying
# exception so that after the event-loop exits we can re-raise
# it to the caller.
class ErrorCollector(object):
exception = None
def __call__(self, failure):
self.exception = failure.value
reactor.stop()
connect_error = ErrorCollector()
d.addErrback(connect_error)
# now enter the Twisted reactor loop
reactor.run()
# if we exited due to a connection error, raise that to the
# caller
if connect_error.exception:
raise connect_error.exception
else:
# let the caller handle any errors
return d
def connect(self, auto_reconnect=True):
def init(proto):
reactor.addSystemEventTrigger('before', 'shutdown', cleanup, proto)
return proto
def cleanup(proto):
session = getattr(proto, '_session', None)
if session is None:
return
if session.is_attached():
return session.leave()
elif session.is_connected():
return session.disconnect()
from twisted.internet import reactor
transport_factory = WampWebSocketClientFactory(self, str(self.address))
transport_factory.setProtocolOptions(
maxFramePayloadSize=1048576,
maxMessagePayloadSize=1048576,
autoFragmentSize=65536,
failByDrop=False,
openHandshakeTimeout=OPEN_HANDSHAKE_TIMEOUT,
closeHandshakeTimeout=CLOSE_HANDSHAKE_TIMEOUT,
tcpNoDelay=True,
autoPingInterval=AUTO_PING_INTERVAL,
autoPingTimeout=AUTO_PING_TIMEOUT,
autoPingSize=4,
)
if self.address.ssl:
if self._cert_manager:
cert_data = self._cert_manager.read_certificate()
authority = twisted_ssl.Certificate.loadPEM(cert_data)
else:
authority = None
context_factory = optionsForClientTLS(X509_COMMON_NAME,
trustRoot=authority)
self._client = SSL4ClientEndpoint(reactor, self.address.host,
self.address.port,
context_factory)
else:
if self._use_ipv6:
endpoint_cls = TCP6ClientEndpoint
else:
endpoint_cls = TCP4ClientEndpoint
self._client = endpoint_cls(reactor, self.address.host,
self.address.port)
if auto_reconnect:
self._reconnect_service = ClientService(
endpoint=self._client,
factory=transport_factory,
retryPolicy=backoffPolicy(factor=BACKOFF_POLICY_FACTOR))
self._reconnect_service.startService()
deferred = self._reconnect_service.whenConnected()
else:
deferred = self._client.connect(transport_factory)
deferred.addCallback(init)
deferred.addErrback(self.ready.errback)
return self.ready
def start_component(self, component, router):
"""
Starts a Class or WAMPlet in this component container.
"""
if component['type'] == 'wamplet':
try:
dist = component['dist']
name = component['entry']
if self.debug:
log.msg("Worker {}: starting WAMPlet '{}/{}' in realm '{}' ..".format(self._pid, dist, name, router['realm']))
## make is supposed to make instances of ApplicationSession
make = pkg_resources.load_entry_point(dist, 'autobahn.twisted.wamplet', name)
except Exception as e:
log.msg("Worker {}: failed to import class - {}".format(e))
raise ApplicationError("crossbar.error.class_import_failed", str(e))
elif component['type'] == 'class':
try:
klassname = component['name']
if self.debug:
log.msg("Worker {}: starting class '{}' in realm '{}' ..".format(self._pid, klassname, router['realm']))
import importlib
c = klassname.split('.')
mod, kls = '.'.join(c[:-1]), c[-1]
app = importlib.import_module(mod)
## make is supposed to be of class ApplicationSession
make = getattr(app, kls)
except Exception as e:
log.msg("Worker {}: failed to import class - {}".format(e))
raise ApplicationError("crossbar.error.class_import_failed", str(e))
else:
raise ApplicationError("crossbar.error.invalid_configuration", "unknown component type '{}'".format(component['type']))
def create():
cfg = ComponentConfig(realm = router['realm'], extra = component.get('extra', None))
c = make(cfg)
return c
## create a WAMP-over-WebSocket transport client factory
##
from autobahn.twisted.websocket import WampWebSocketClientFactory
transport_factory = WampWebSocketClientFactory(create, router['url'], debug = self.debug)
transport_factory.setProtocolOptions(failByDrop = False)
## start a WebSocket client from an endpoint
##
from twisted.internet import reactor
from twisted.internet.endpoints import TCP4ClientEndpoint, SSL4ClientEndpoint, UNIXClientEndpoint
from twisted.internet.endpoints import clientFromString
from crossbar.twisted.tlsctx import TlsClientContextFactory
if False:
self._client = clientFromString(reactor, router['endpoint'])
else:
try:
endpoint_config = router.get('endpoint')
## a TCP4 endpoint
##
if endpoint_config['type'] == 'tcp':
## the host to connect ot
##
host = str(endpoint_config['host'])
## the port to connect to
##
port = int(endpoint_config['port'])
## connection timeout in seconds
##
timeout = int(endpoint_config.get('timeout', 10))
if 'tls' in endpoint_config:
ctx = TlsClientContextFactory()
## create a TLS client endpoint
##
self._client = SSL4ClientEndpoint(reactor,
host,
port,
ctx,
timeout = timeout)
else:
## create a non-TLS client endpoint
##
self._client = TCP4ClientEndpoint(reactor,
host,
port,
timeout = timeout)
## a Unix Domain Socket endpoint
##
elif endpoint_config['type'] == 'unix':
## the path
##
path = os.path.abspath(os.path.join(self._cbdir, endpoint_config['path']))
## connection timeout in seconds
##
timeout = int(endpoint_config['type'].get('timeout', 10))
## create the endpoint
##
self._client = UNIXClientEndpoint(reactor, path, timeout = timeout)
else:
raise ApplicationError("crossbar.error.invalid_configuration", "invalid endpoint type '{}'".format(endpoint_config['type']))
except Exception as e:
log.msg("endpoint creation failed: {}".format(e))
raise e
retry = True
retryDelay = 1000
def try_connect():
if self.debug:
log.msg("Worker {}: connecting to router ..".format(self._pid))
d = self._client.connect(transport_factory)
def success(res):
if self.debug:
log.msg("Worker {}: client connected to router".format(self._pid))
def error(err):
log.msg("Worker {}: client failed to connect to router - {}".format(self._pid, err))
if retry:
log.msg("Worker {}: retrying in {} ms".format(self._pid, retryDelay))
reactor.callLater(float(retryDelay) / 1000., try_connect)
else:
log.msg("Worker {}: giving up.".format(seld._pid))
d.addCallbacks(success, error)
try_connect()
from autobahn.twisted.choosereactor import install_reactor
from autobahn.twisted.websocket import WampWebSocketClientFactory
from autobahn.twisted.wamp import ApplicationSessionFactory
from autobahn.twisted.wamp import ApplicationSession
from autobahn.wamp import types
class MySession(ApplicationSession):
def onJoin(self, details):
print("Session attached to realm!")
log.startLogging(sys.stdout)
reactor = install_reactor()
print("Running on reactor {}".format(reactor))
session_factory = ApplicationSessionFactory(
types.ComponentConfig(realm=u"realm1"))
session_factory.session = MySession
transport_factory = WampWebSocketClientFactory(session_factory,
url="ws://localhost",
debug=True)
client = clientFromString(reactor, "unix:/tmp/cbsocket")
client.connect(transport_factory)
reactor.run()
def __init__(self, *args, **kwargs):
self._authrole = kwargs.pop('authrole')
WampWebSocketClientFactory.__init__(self, *args, **kwargs)
self.proto = None
class Node:
"""
A Crossbar.io node is the running a controller process
and one or multiple worker processes.
A single Crossbar.io node runs exactly one instance of
this class, hence this class can be considered a system
singleton.
"""
def __init__(self, reactor, cbdir, debug = False):
"""
Ctor.
:param reactor: Reactor to run on.
:type reactor: obj
:param cbdir: Crossbar.io node directory to run from.
:type cbdir: str
"""
self.debug = debug
self._reactor = reactor
self._cbdir = cbdir
self._worker_processes = {}
## node name: FIXME
self._node_name = "{}-{}".format(socket.getfqdn(), os.getpid())
self._node_name.replace('-', '_')
self._node_name = '918234'
## node management
self._management_url = "ws://127.0.0.1:7000"
#self._management_url = "wss://cloud.crossbar.io"
self._management_realm = "crossbar.cloud.aliceblue"
## load Crossbar.io node configuration
##
cf = os.path.join(self._cbdir, 'config.json')
with open(cf, 'rb') as infile:
self._config = json.load(infile)
def start(self):
"""
Starts this node. This will start a node controller
and then spawn new worker processes as needed.
The node controller will watch spawned processes,
communicate via stdio with the worker, and start
and restart the worker processes as needed.
"""
## the node controller singleton WAMP application session
##
self._node_controller_session = NodeControllerSession(self)
## router and factory that creates router sessions
##
self._router_factory = RouterFactory()
self._router_session_factory = RouterSessionFactory(self._router_factory)
## add the node controller singleton session to the router
##
self._router_session_factory.add(self._node_controller_session)
if True:
## create a WAMP-over-WebSocket transport server factory
##
from autobahn.twisted.websocket import WampWebSocketServerFactory
from twisted.internet.endpoints import serverFromString
self._router_server_transport_factory = WampWebSocketServerFactory(self._router_session_factory, "ws://localhost:9000", debug = False)
self._router_server_transport_factory.setProtocolOptions(failByDrop = False)
## start the WebSocket server from an endpoint
##
self._router_server = serverFromString(self._reactor, "tcp:9000")
self._router_server.listen(self._router_server_transport_factory)
## factory that creates router session transports. these are for clients
## that talk WAMP-WebSocket over pipes with spawned worker processes and
## for any uplink session to a management service
##
self._router_client_transport_factory = WampWebSocketClientFactory(self._router_session_factory, "ws://localhost", debug = False)
self._router_client_transport_factory.setProtocolOptions(failByDrop = False)
if False:
management_session_factory = ApplicationSessionFactory()
management_session_factory.session = NodeManagementSession
management_session_factory.node_controller_session = node_controller_session
management_transport_factory = WampWebSocketClientFactory(management_session_factory, "ws://127.0.0.1:7000")
management_transport_factory.setProtocolOptions(failByDrop = False)
management_client = clientFromString(self._reactor, "tcp:127.0.0.1:7000")
management_client.connect(management_transport_factory)
## startup the node from configuration file
##
self._node_controller_session.run_node_config(self._config)
def run(self,
make,
start_reactor: bool = True,
auto_reconnect: bool = False,
log_level: str = 'info',
endpoint: Optional[IStreamClientEndpoint] = None,
reactor: Optional[IReactorCore] = None
) -> Union[type(None), Deferred]:
"""
Run the application component.
:param make: A factory that produces instances of :class:`autobahn.twisted.wamp.ApplicationSession`
when called with an instance of :class:`autobahn.wamp.types.ComponentConfig`.
:param start_reactor: When ``True`` (the default) this method starts
the Twisted reactor and doesn't return until the reactor
stops. If there are any problems starting the reactor or
connect()-ing, we stop the reactor and raise the exception
back to the caller.
:param auto_reconnect:
:param log_level:
:param endpoint:
:param reactor:
:return: None is returned, unless you specify
``start_reactor=False`` in which case the Deferred that
connect() returns is returned; this will callback() with
an IProtocol instance, which will actually be an instance
of :class:`WampWebSocketClientProtocol`
"""
self.log.debug('{klass}.run()', klass=self.__class__.__name__)
if start_reactor:
# only select framework, set loop and start logging when we are asked
# start the reactor - otherwise we are running in a program that likely
# already tool care of all this.
from twisted.internet import reactor
txaio.use_twisted()
txaio.config.loop = reactor
txaio.start_logging(level=log_level)
if callable(make):
# factory for use ApplicationSession
def create():
cfg = ComponentConfig(self.realm, self.extra, runner=self)
try:
session = make(cfg)
except Exception:
self.log.failure(
'ApplicationSession could not be instantiated: {log_failure.value}'
)
if start_reactor and reactor.running:
reactor.stop()
raise
else:
return session
else:
create = make
if self.url.startswith('rs'):
# try to parse RawSocket URL
isSecure, host, port = parse_rs_url(self.url)
# use the first configured serializer if any (which means, auto-choose "best")
serializer = self.serializers[0] if self.serializers else None
# create a WAMP-over-RawSocket transport client factory
transport_factory = WampRawSocketClientFactory(
create, serializer=serializer)
else:
# try to parse WebSocket URL
isSecure, host, port, resource, path, params = parse_ws_url(
self.url)
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(
create,
url=self.url,
serializers=self.serializers,
proxy=self.proxy,
headers=self.headers)
# client WebSocket settings - similar to:
# - http://crossbar.io/docs/WebSocket-Compression/#production-settings
# - http://crossbar.io/docs/WebSocket-Options/#production-settings
# The permessage-deflate extensions offered to the server
offers = [PerMessageDeflateOffer()]
# Function to accept permessage-deflate responses from the server
def accept(response):
if isinstance(response, PerMessageDeflateResponse):
return PerMessageDeflateResponseAccept(response)
# default WebSocket options for all client connections
protocol_options = {
'version': WebSocketProtocol.DEFAULT_SPEC_VERSION,
'utf8validateIncoming': True,
'acceptMaskedServerFrames': False,
'maskClientFrames': True,
'applyMask': True,
'maxFramePayloadSize': 1048576,
'maxMessagePayloadSize': 1048576,
'autoFragmentSize': 65536,
'failByDrop': True,
'echoCloseCodeReason': False,
'serverConnectionDropTimeout': 1.,
'openHandshakeTimeout': 2.5,
'closeHandshakeTimeout': 1.,
'tcpNoDelay': True,
'perMessageCompressionOffers': offers,
'perMessageCompressionAccept': accept,
'autoPingInterval': 10.,
'autoPingTimeout': 5.,
'autoPingSize': 12,
# see: https://github.com/crossbario/autobahn-python/issues/1327 and
# _cancelAutoPingTimeoutCall
'autoPingRestartOnAnyTraffic': True,
}
# let user override above default options
if self.websocket_options:
protocol_options.update(self.websocket_options)
# set websocket protocol options on Autobahn/Twisted protocol factory, from where it will
# be applied for every Autobahn/Twisted protocol instance from the factory
transport_factory.setProtocolOptions(**protocol_options)
# supress pointless log noise
transport_factory.noisy = False
if endpoint:
client = endpoint
else:
# if user passed ssl= but isn't using isSecure, we'll never
# use the ssl argument which makes no sense.
context_factory = None
if self.ssl is not None:
if not isSecure:
raise RuntimeError(
'ssl= argument value passed to %s conflicts with the "ws:" '
'prefix of the url argument. Did you mean to use "wss:"?'
% self.__class__.__name__)
context_factory = self.ssl
elif isSecure:
from twisted.internet.ssl import optionsForClientTLS
context_factory = optionsForClientTLS(host)
from twisted.internet import reactor
if self.proxy is not None:
from twisted.internet.endpoints import TCP4ClientEndpoint
client = TCP4ClientEndpoint(reactor, self.proxy['host'],
self.proxy['port'])
transport_factory.contextFactory = context_factory
elif isSecure:
from twisted.internet.endpoints import SSL4ClientEndpoint
assert context_factory is not None
client = SSL4ClientEndpoint(reactor, host, port,
context_factory)
else:
from twisted.internet.endpoints import TCP4ClientEndpoint
client = TCP4ClientEndpoint(reactor, host, port)
# as the reactor shuts down, we wish to wait until we've sent
# out our "Goodbye" message; leave() returns a Deferred that
# fires when the transport gets to STATE_CLOSED
def cleanup(proto):
if hasattr(proto, '_session') and proto._session is not None:
if proto._session.is_attached():
return proto._session.leave()
elif proto._session.is_connected():
return proto._session.disconnect()
# when our proto was created and connected, make sure it's cleaned
# up properly later on when the reactor shuts down for whatever reason
def init_proto(proto):
self._connect_successes += 1
reactor.addSystemEventTrigger('before', 'shutdown', cleanup, proto)
return proto
use_service = False
if auto_reconnect:
try:
# since Twisted 16.1.0
from twisted.application.internet import ClientService
from twisted.application.internet import backoffPolicy
use_service = True
except ImportError:
use_service = False
if use_service:
# this code path is automatically reconnecting ..
self.log.debug('using t.a.i.ClientService')
if (self.max_retries is not None
or self.initial_retry_delay is not None
or self.max_retry_delay is not None
or self.retry_delay_growth is not None
or self.retry_delay_jitter is not None):
if self.max_retry_delay > 0:
kwargs = {}
def _jitter():
j = 1 if self.retry_delay_jitter is None else self.retry_delay_jitter
return random.random() * j
for key, val in [('initialDelay',
self.initial_retry_delay),
('maxDelay', self.max_retry_delay),
('factor', self.retry_delay_growth),
('jitter', _jitter)]:
if val is not None:
kwargs[key] = val
# retry policy that will only try to reconnect if we connected
# successfully at least once before (so it fails on host unreachable etc ..)
def retry(failed_attempts):
if self._connect_successes > 0 and (
self.max_retries == -1
or failed_attempts < self.max_retries):
return backoffPolicy(**kwargs)(failed_attempts)
else:
print('hit stop')
self.stop()
return 100000000000000
else:
# immediately reconnect (zero delay)
def retry(_):
return 0
else:
retry = backoffPolicy()
# https://twistedmatrix.com/documents/current/api/twisted.application.internet.ClientService.html
self._client_service = ClientService(client,
transport_factory,
retryPolicy=retry)
self._client_service.startService()
d = self._client_service.whenConnected()
else:
# this code path is only connecting once!
self.log.debug('using t.i.e.connect()')
d = client.connect(transport_factory)
# if we connect successfully, the arg is a WampWebSocketClientProtocol
d.addCallback(init_proto)
# if the user didn't ask us to start the reactor, then they
# get to deal with any connect errors themselves.
if start_reactor:
# if an error happens in the connect(), we save the underlying
# exception so that after the event-loop exits we can re-raise
# it to the caller.
class ErrorCollector(object):
exception = None
def __call__(self, failure):
self.exception = failure.value
reactor.stop()
connect_error = ErrorCollector()
d.addErrback(connect_error)
# now enter the Twisted reactor loop
reactor.run()
# if the ApplicationSession sets an "error" key on the self.config.extra dictionary, which
# has been set to the self.extra dictionary, extract the Exception from that and re-raise
# it as the very last one (see below) exciting back to the caller of self.run()
app_error = self.extra.get('error', None)
# if we exited due to a connection error, raise that to the caller
if connect_error.exception:
raise connect_error.exception
elif app_error:
raise app_error
else:
# let the caller handle any errors
return d
def start(self, transport, klassname, realm):
"""
Dynamically start an application component to run next to the router in "embedded mode".
"""
## dynamically load the application component ..
##
try:
if self.debug:
log.msg("Worker {}: starting class '{}' in realm '{}' ..".format(self._pid, klassname, realm))
import importlib
c = klassname.split('.')
mod, klass = '.'.join(c[:-1]), c[-1]
app = importlib.import_module(mod)
SessionKlass = getattr(app, klass)
except Exception as e:
if self.debug:
log.msg("Worker {}: failed to import class - {}".format(e))
raise ApplicationError("crossbar.error.class_import_failed", str(e))
else:
## create a WAMP application session factory
##
#from autobahn.twisted.wamp import ApplicationSessionFactory
#session_factory = ApplicationSessionFactory()
session_factory = ComponentSessionFactory(realm)
session_factory.session = SessionKlass
## create a WAMP-over-WebSocket transport client factory
##
from autobahn.twisted.websocket import WampWebSocketClientFactory
transport_factory = WampWebSocketClientFactory(session_factory, transport['url'], debug = self.debug)
transport_factory.setProtocolOptions(failByDrop = False)
## start a WebSocket client from an endpoint
##
from twisted.internet import reactor
from twisted.internet.endpoints import TCP4ClientEndpoint, SSL4ClientEndpoint, UNIXClientEndpoint
from twisted.internet.endpoints import clientFromString
from tlsctx import TlsClientContextFactory
if False:
self._client = clientFromString(reactor, transport['endpoint'])
else:
try:
endpoint_config = transport.get('endpoint')
## a TCP4 endpoint
##
if endpoint_config['type'] == 'tcp':
## the host to connect ot
##
host = str(endpoint_config['host'])
## the port to connect to
##
port = int(endpoint_config['port'])
## connection timeout in seconds
##
timeout = int(endpoint_config.get('timeout', 10))
if 'tls' in endpoint_config:
ctx = TlsClientContextFactory()
## create a TLS client endpoint
##
self._client = SSL4ClientEndpoint(reactor,
host,
port,
ctx,
timeout = timeout)
else:
## create a non-TLS client endpoint
##
self._client = TCP4ClientEndpoint(reactor,
host,
port,
timeout = timeout)
## a Unix Domain Socket endpoint
##
elif endpoint_config['type'] == 'unix':
## the path
##
path = str(endpoint_config['path'])
## connection timeout in seconds
##
timeout = int(endpoint_config['type'].get('timeout', 10))
## create the endpoint
##
self._client = UNIXClientEndpoint(reactor, path, timeout = timeout)
else:
raise ApplicationError("crossbar.error.invalid_configuration", "invalid endpoint type '{}'".format(endpoint_config['type']))
except Exception as e:
log.msg("endpoint creation failed: {}".format(e))
raise e
retry = True
retryDelay = 1000
def try_connect():
print "Trying to connect .."
d = self._client.connect(transport_factory)
def success(res):
if True or self.debug:
log.msg("Worker {}: client connected to router".format(self._pid))
def error(err):
log.msg("Worker {}: client failed to connect to router - {}".format(self._pid, err))
if retry:
log.msg("Worker {}: retrying in {} ms".format(self._pid, retryDelay))
reactor.callLater(float(retryDelay) / 1000., try_connect)
else:
log.msg("Worker {}: giving up.".format(seld._pid))
d.addCallbacks(success, error)
try_connect()
def __init__(self, factory, *args, **kwargs):
WampWebSocketClientFactory.__init__(self, factory, *args, **kwargs)
self.protocol_instance = None
self.base_client = None
## dynamically load the application component ..
##
import importlib
c = args.component.split('.')
mod, klass = '.'.join(c[:-1]), c[-1]
app = importlib.import_module(mod)
## .. and set the session class on the factory
##
session_factory.session = getattr(app, klass)
## create a WAMP-over-WebSocket transport client factory
##
from autobahn.twisted.websocket import WampWebSocketClientFactory
transport_factory = WampWebSocketClientFactory(session_factory, args.wsurl, debug = args.debug)
transport_factory.setProtocolOptions(failByDrop = False)
## start a WebSocket client from an endpoint
##
client = clientFromString(reactor, args.websocket)
client.connect(transport_factory)
## now enter the Twisted reactor loop
##
reactor.run()
import importlib
c = args.component.split('.')
mod, klass = '.'.join(c[:-1]), c[-1]
app = importlib.import_module(mod)
## .. and set the session class on the factory
##
session_factory.session = getattr(app, klass)
if args.transport == "websocket":
## create a WAMP-over-WebSocket transport client factory
##
from autobahn.twisted.websocket import WampWebSocketClientFactory
transport_factory = WampWebSocketClientFactory(session_factory,
url=args.url,
debug_wamp=args.debug)
transport_factory.setProtocolOptions(failByDrop=False)
elif args.transport in ['rawsocket-json', 'rawsocket-msgpack']:
## create a WAMP-over-RawSocket transport client factory
##
if args.transport == 'rawsocket-msgpack':
from autobahn.wamp.serializer import MsgPackSerializer
serializer = MsgPackSerializer()
elif args.transport == 'rawsocket-json':
from autobahn.wamp.serializer import JsonSerializer
serializer = JsonSerializer()
else:
raise Exception("should not arrive here")
def __init__(self, url, **kwargs):
return WampWebSocketClientFactory.__init__(self, url, **kwargs)
def __init__(self, url, **kwargs):
return WampWebSocketClientFactory.__init__(self, url, **kwargs)
def stopFactory(self):
WampWebSocketClientFactory.stopFactory(self)
if self.proto:
self.proto.close()
def buildProtocol(self, addr):
self._proto = WampWebSocketClientFactory.buildProtocol(self, addr)
return self._proto
def run(self, make, start_reactor=True):
"""
Run the application component.
:param make: A factory that produces instances of :class:`autobahn.asyncio.wamp.ApplicationSession`
when called with an instance of :class:`autobahn.wamp.types.ComponentConfig`.
:type make: callable
:param start_reactor: if True (the default) this method starts
the Twisted reactor and doesn't return until the reactor
stops. If there are any problems starting the reactor or
connect()-ing, we stop the reactor and raise the exception
back to the caller.
:returns: None is returned, unless you specify
``start_reactor=False`` in which case the Deferred that
connect() returns is returned; this will callback() with
an IProtocol instance, which will actually be an instance
of :class:`WampWebSocketClientProtocol`
"""
from twisted.internet import reactor
txaio.use_twisted()
txaio.config.loop = reactor
isSecure, host, port, resource, path, params = parseWsUrl(self.url)
# start logging to console
if self.debug or self.debug_wamp or self.debug_app:
log.startLogging(sys.stdout)
# factory for use ApplicationSession
def create():
cfg = ComponentConfig(self.realm, self.extra)
try:
session = make(cfg)
except Exception as e:
if start_reactor:
# the app component could not be created .. fatal
log.err(str(e))
reactor.stop()
else:
# if we didn't start the reactor, it's up to the
# caller to deal with errors
raise
else:
session.debug_app = self.debug_app
return session
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(
create, url=self.url, debug=self.debug, debug_wamp=self.debug_wamp)
# if user passed ssl= but isn't using isSecure, we'll never
# use the ssl argument which makes no sense.
context_factory = None
if self.ssl is not None:
if not isSecure:
raise RuntimeError(
'ssl= argument value passed to %s conflicts with the "ws:" '
'prefix of the url argument. Did you mean to use "wss:"?' %
self.__class__.__name__)
context_factory = self.ssl
elif isSecure:
from twisted.internet.ssl import optionsForClientTLS
context_factory = optionsForClientTLS(six.u(host))
if isSecure:
from twisted.internet.endpoints import SSL4ClientEndpoint
assert context_factory is not None
client = SSL4ClientEndpoint(reactor, host, port, context_factory)
else:
from twisted.internet.endpoints import TCP4ClientEndpoint
client = TCP4ClientEndpoint(reactor, host, port)
d = client.connect(transport_factory)
# as the reactor shuts down, we wish to wait until we've sent
# out our "Goodbye" message; leave() returns a Deferred that
# fires when the transport gets to STATE_CLOSED
def cleanup(proto):
if hasattr(proto, '_session') and proto._session is not None:
return proto._session.leave()
# if we connect successfully, the arg is a WampWebSocketClientProtocol
d.addCallback(lambda proto: reactor.addSystemEventTrigger(
'before', 'shutdown', cleanup, proto))
# if the user didn't ask us to start the reactor, then they
# get to deal with any connect errors themselves.
if start_reactor:
# if an error happens in the connect(), we save the underlying
# exception so that after the event-loop exits we can re-raise
# it to the caller.
class ErrorCollector(object):
exception = None
def __call__(self, failure):
self.exception = failure.value
# print(failure.getErrorMessage())
reactor.stop()
connect_error = ErrorCollector()
d.addErrback(connect_error)
# now enter the Twisted reactor loop
reactor.run()
# if we exited due to a connection error, raise that to the
# caller
if connect_error.exception:
raise connect_error.exception
else:
# let the caller handle any errors
return d
def __init__(self, *args, **kwargs):
WampWebSocketClientFactory.__init__(self, *args, **kwargs)
self.proto = None
##
session_factory.session = MyAppComponent
## since we are running this component as a client, there
## will be only 1 app session instance anyway. We'll store a
## reference on the session factory, so we can access it
## from "outside" the session instance later (see below)
##
session_factory._myAppSession = None
## create a WAMP-over-WebSocket transport client factory
##
from autobahn.twisted.websocket import WampWebSocketClientFactory
transport_factory = WampWebSocketClientFactory(session_factory, "ws://127.0.0.1:8080/ws")
## start a WebSocket client from an endpoint
##
client = clientFromString(reactor, "tcp:127.0.0.1:8080")
client.connect(transport_factory)
## publish an event every second from the (single) application session
## that get created by the session factory
##
@inlineCallbacks
def pub():
counter = 0
while True:
