def test_use_twisted(framework_tx): pytest.importorskip('twisted') import txaio txaio.use_twisted() assert txaio.using_twisted assert not txaio.using_asyncio
def test_use_twisted_no_twisted(framework_uninitialized): # make sure we DO NOT have Twisted installed try: import twisted # noqa return except ImportError: pass # no Twisted import txaio try: txaio.use_twisted() assert "Should have gotten ImportError" except ImportError: pass assert not txaio.using_twisted
def install_reactor(explicit_reactor=None, verbose=False): """ Install Twisted reactor. :param explicit_reactor: If provided, install this reactor. Else, install the optimal reactor. :type explicit_reactor: obj :param verbose: If ``True``, print what happens. :type verbose: bool """ import sys import txaio txaio.use_twisted() # just to be sure... log = make_logger() if explicit_reactor: # install explicitly given reactor ## from twisted.application.reactors import installReactor log.info("Trying to install explicitly specified Twisted reactor '{reactor}'", reactor=explicit_reactor) try: installReactor(explicit_reactor) except: log.failure("Could not install Twisted reactor {reactor}\n{log_failure.value}", reactor=explicit_reactor) sys.exit(1) else: # automatically choose optimal reactor ## log.debug("Automatically choosing optimal Twisted reactor") install_optimal_reactor(verbose) # now the reactor is installed, import it from twisted.internet import reactor txaio.config.loop = reactor if verbose: from twisted.python.reflect import qual log.debug("Running Twisted reactor {reactor}", reactor=qual(reactor.__class__)) return reactor
def install_reactor(explicitReactor=None, verbose=False): """ Install Twisted reactor. :param explicitReactor: If provided, install this reactor. Else, install optimal reactor. :type explicitReactor: obj :param verbose: If ``True``, print what happens. :type verbose: bool """ import sys import txaio txaio.use_twisted() # just to be sure... if explicitReactor: # install explicitly given reactor ## from twisted.application.reactors import installReactor print("Trying to install explicitly specified Twisted reactor '%s'" % explicitReactor) try: installReactor(explicitReactor) except Exception as e: print("Could not install Twisted reactor %s%s" % (explicitReactor, ' ["%s"]' % e if verbose else '')) sys.exit(1) else: # automatically choose optimal reactor ## if verbose: print("Automatically choosing optimal Twisted reactor") install_optimal_reactor(verbose) # now the reactor is installed, import it from twisted.internet import reactor txaio.config.loop = reactor if verbose: from twisted.python.reflect import qual print("Running Twisted reactor %s" % qual(reactor.__class__)) return reactor
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 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 config_logging(suffix='', datadir=None, loglevel=None, config_desc=None): """Config logger""" try: from loggingconfig_local import LOGGING except ImportError: from loggingconfig import LOGGING if datadir is None: datadir = simpleenv.get_local_datadir("default") logdir_path = os.path.join(datadir, 'logs') for handler_name, handler in LOGGING.get('handlers', {}).items(): if 'filename' in handler: handler['filename'] %= { 'logdir': str(logdir_path), 'suffix': suffix, } skip_handler_names = ( 'error-file', 'sentry', 'sentry-metrics', ) if handler_name in skip_handler_names: # Don't modify loglevel in this handler continue if loglevel: handler['level'] = loglevel if loglevel: for _logger in LOGGING.get('loggers', {}).values(): _logger['level'] = loglevel LOGGING['root']['level'] = loglevel if config_desc and not config_desc.debug_third_party: LOGGING['loggers']['golem.rpc.crossbar']['level'] = 'WARNING' LOGGING['loggers']['twisted']['level'] = 'WARNING' try: if not os.path.exists(logdir_path): os.makedirs(logdir_path) logging.config.dictConfig(LOGGING) except (ValueError, PermissionError) as e: sys.stderr.write("Can't configure logging in: {} Got: {}\n".format( logdir_path, e)) return # Avoid consequent errors logging.captureWarnings(True) from golem.tools.talkback import enable_sentry_logger enable_sentry_logger(False) import txaio txaio.use_twisted() from ethereum import slogging if config_desc and config_desc.debug_third_party: slogging.configure(':debug') else: slogging.configure(':warning') from twisted.python import log observer = log.PythonLoggingObserver(loggerName='twisted') observer.start() crossbar_log_lvl = logging.getLevelName( logging.getLogger('golem.rpc.crossbar').level).lower() # Fix inconsistency in log levels, only warn affected if crossbar_log_lvl == 'warning': crossbar_log_lvl = 'warn' txaio.set_global_log_level(crossbar_log_lvl) # pylint: disable=no-member
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # ############################################################################### from __future__ import absolute_import import six import inspect import txaio txaio.use_twisted() # noqa from twisted.internet.defer import inlineCallbacks from autobahn.websocket.util import parse_url as parse_ws_url from autobahn.rawsocket.util import parse_url as parse_rs_url from autobahn.twisted.websocket import WampWebSocketClientFactory from autobahn.twisted.rawsocket import WampRawSocketClientFactory from autobahn.websocket.compress import PerMessageDeflateOffer, \ PerMessageDeflateResponse, PerMessageDeflateResponseAccept from autobahn.wamp import protocol from autobahn.wamp.types import ComponentConfig
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) # 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) d = client.connect(transport_factory) # 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
import os import argparse import six import txaio txaio.use_twisted() from twisted.internet import reactor from twisted.internet.defer import inlineCallbacks from twisted.internet.error import ReactorNotRunning from autobahn.twisted.wamp import ApplicationSession, ApplicationRunner from autobahn.twisted.util import sleep from autobahn.wamp.exception import ApplicationError from autobahn.wamp.types import SubscribeOptions, RegisterOptions class ClientSession(ApplicationSession): log = txaio.make_logger() _this_service = u'service1' _other_services = [u'service0', u'service2', u'service3'] def onConnect(self): self.log.info("Client connected") self.join(self.config.realm, [u'anonymous']) def onChallenge(self, challenge): self.log.info("Challenge for method {authmethod} received", authmethod=challenge.method) raise Exception("We haven't asked for authentication!")
##################################################################################### from __future__ import absolute_import import argparse import click import json import os import pkg_resources import platform import signal import sys import six import txaio txaio.use_twisted() # noqa from txaio import make_logger, start_logging, set_global_log_level from twisted.python.reflect import qual from twisted.logger import globalLogPublisher from crossbar._logging import make_logfile_observer from crossbar._logging import make_stdout_observer from crossbar._logging import make_stderr_observer from crossbar._logging import LogLevel import crossbar from autobahn.twisted.choosereactor import install_reactor from autobahn.websocket.protocol import WebSocketProtocol from autobahn.websocket.utf8validator import Utf8Validator
def run(self, make, start_reactor=True, auto_reconnect=False, log_level='info', endpoint=None, reactor=None): """ 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`. :type make: callable :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. :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` """ 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_delate responses from the server .. def accept(response): if isinstance(response, PerMessageDeflateResponse): return PerMessageDeflateResponseAccept(response) # set WebSocket options for all client connections transport_factory.setProtocolOptions( maxFramePayloadSize=1048576, maxMessagePayloadSize=1048576, autoFragmentSize=65536, failByDrop=False, openHandshakeTimeout=2.5, closeHandshakeTimeout=1., tcpNoDelay=True, autoPingInterval=10., autoPingTimeout=5., autoPingSize=4, perMessageCompressionOffers=offers, perMessageCompressionAccept=accept) # 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 or self.initial_retry_delay or self.max_retry_delay or self.retry_delay_growth or self.retry_delay_jitter: 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: 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: retry = backoffPolicy() 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 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 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) # 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) d = client.connect(transport_factory) # 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 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 self.session = session return session # create a WAMP-over-WebSocket transport client factory transport_factory = WampWebSocketClientFactory( create, url=self.url, serializers=self.serializers, 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(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() # 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 # 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 install_optimal_reactor(verbose=False): """ Try to install the optimal Twisted reactor for this platform. :param verbose: If ``True``, print what happens. :type verbose: bool """ log = make_logger() import sys from twisted.python import reflect import txaio txaio.use_twisted() # just to be sure... # XXX should I configure txaio.config.loop in here too, or just in # install_reactor()? (I am: see bottom of function) # determine currently installed reactor, if any ## if 'twisted.internet.reactor' in sys.modules: current_reactor = reflect.qual(sys.modules['twisted.internet.reactor'].__class__).split('.')[-1] else: current_reactor = None # depending on platform, install optimal reactor ## if 'bsd' in sys.platform or sys.platform.startswith('darwin'): # *BSD and MacOSX ## if current_reactor != 'KQueueReactor': try: from twisted.internet import kqreactor kqreactor.install() except: log.critical("Running on *BSD or MacOSX, but cannot install kqueue Twisted reactor") log.debug(traceback.format_exc()) else: log.debug("Running on *BSD or MacOSX and optimal reactor (kqueue) was installed.") else: log.debug("Running on *BSD or MacOSX and optimal reactor (kqueue) already installed.") elif sys.platform in ['win32']: # Windows ## if current_reactor != 'IOCPReactor': try: from twisted.internet.iocpreactor import reactor as iocpreactor iocpreactor.install() except: log.critical("Running on Windows, but cannot install IOCP Twisted reactor") log.debug(traceback.format_exc()) else: log.debug("Running on Windows and optimal reactor (ICOP) was installed.") else: log.debug("Running on Windows and optimal reactor (ICOP) already installed.") elif sys.platform.startswith('linux'): # Linux ## if current_reactor != 'EPollReactor': try: from twisted.internet import epollreactor epollreactor.install() except: log.critical("Running on Linux, but cannot install Epoll Twisted reactor") log.debug(traceback.format_exc()) else: log.debug("Running on Linux and optimal reactor (epoll) was installed.") else: log.debug("Running on Linux and optimal reactor (epoll) already installed.") else: try: from twisted.internet import default as defaultreactor defaultreactor.install() except: log.critical("Could not install default Twisted reactor for this platform") log.debug(traceback.format_exc()) from twisted.internet import reactor txaio.config.loop = reactor
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # ############################################################################### from __future__ import absolute_import import hashlib import os from mock import Mock import txaio if os.environ.get('USE_TWISTED', False): txaio.use_twisted() elif os.environ.get('USE_ASYNCIO', False): txaio.use_asyncio() else: raise Exception('no networking framework selected') from autobahn.wamp.cryptosign import _makepad, HAS_CRYPTOSIGN from autobahn.wamp import types from autobahn.wamp.auth import create_authenticator if HAS_CRYPTOSIGN: from autobahn.wamp.cryptosign import SigningKey from nacl.encoding import HexEncoder import tempfile
def install_optimal_reactor(verbose=False): """ Try to install the optimal Twisted reactor for platform. :param verbose: If ``True``, print what happens. :type verbose: bool """ import sys from twisted.python import reflect import txaio txaio.use_twisted() # just to be sure... # XXX should I configure txaio.config.loop in here too, or just in # install_reactor()? (I am: see bottom of function) # determine currently installed reactor, if any ## if 'twisted.internet.reactor' in sys.modules: current_reactor = reflect.qual(sys.modules['twisted.internet.reactor'].__class__).split('.')[-1] else: current_reactor = None # depending on platform, install optimal reactor ## if 'bsd' in sys.platform or sys.platform.startswith('darwin'): # *BSD and MacOSX ## if current_reactor != 'KQueueReactor': try: v = sys.version_info if v[0] == 1 or (v[0] == 2 and v[1] < 6) or (v[0] == 2 and v[1] == 6 and v[2] < 5): raise Exception("Python version too old ({0}) to use kqueue reactor".format(sys.version)) from twisted.internet import kqreactor kqreactor.install() except Exception as e: print("WARNING: Running on *BSD or MacOSX, but cannot install kqueue Twisted reactor ({0}).".format(e)) else: if verbose: print("Running on *BSD or MacOSX and optimal reactor (kqueue) was installed.") else: if verbose: print("Running on *BSD or MacOSX and optimal reactor (kqueue) already installed.") elif sys.platform in ['win32']: # Windows ## if current_reactor != 'IOCPReactor': try: from twisted.internet.iocpreactor import reactor as iocpreactor iocpreactor.install() except Exception as e: print("WARNING: Running on Windows, but cannot install IOCP Twisted reactor ({0}).".format(e)) else: if verbose: print("Running on Windows and optimal reactor (ICOP) was installed.") else: if verbose: print("Running on Windows and optimal reactor (ICOP) already installed.") elif sys.platform.startswith('linux'): # Linux ## if current_reactor != 'EPollReactor': try: from twisted.internet import epollreactor epollreactor.install() except Exception as e: print("WARNING: Running on Linux, but cannot install Epoll Twisted reactor ({0}).".format(e)) else: if verbose: print("Running on Linux and optimal reactor (epoll) was installed.") else: if verbose: print("Running on Linux and optimal reactor (epoll) already installed.") else: try: from twisted.internet import default as defaultreactor defaultreactor.install() except Exception as e: print("WARNING: Could not install default Twisted reactor for this platform ({0}).".format(e)) from twisted.internet import reactor txaio.config.loop = reactor
def run(self, make, start_reactor=True, auto_reconnect=False, log_level='info'): """ 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 txaio.start_logging(level=log_level) if callable(make): # factory for use ApplicationSession def create(): cfg = ComponentConfig(self.realm, self.extra) 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(u'rs'): # try to parse RawSocket URL .. isSecure, host, port = parse_rs_url(self.url) # create a WAMP-over-RawSocket transport client factory transport_factory = WampRawSocketClientFactory(create) 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_delate responses from the server .. def accept(response): if isinstance(response, PerMessageDeflateResponse): return PerMessageDeflateResponseAccept(response) # set WebSocket options for all client connections transport_factory.setProtocolOptions(maxFramePayloadSize=1048576, maxMessagePayloadSize=1048576, autoFragmentSize=65536, failByDrop=False, openHandshakeTimeout=2.5, closeHandshakeTimeout=1., tcpNoDelay=True, autoPingInterval=10., autoPingTimeout=5., autoPingSize=4, perMessageCompressionOffers=offers, perMessageCompressionAccept=accept) # supress pointless log noise 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) # 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 use_service = False if auto_reconnect: try: # since Twisted 16.1.0 from twisted.application.internet import ClientService use_service = True except ImportError: use_service = False if use_service: self.log.debug('using t.a.i.ClientService') # this is automatically reconnecting service = ClientService(client, transport_factory) service.startService() d = service.whenConnected() else: # this 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 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
from autobahn.twisted.websocket import connectWS, WebSocketClientFactory, WebSocketClientProtocol from autobahn.websocket.compress import ( PerMessageDeflateOffer, PerMessageDeflateResponse, PerMessageDeflateResponseAccept, ) import requests from twisted.internet import reactor from twisted.internet.protocol import ReconnectingClientFactory from twisted.python import log from txaio import start_logging, use_twisted import re from modules.parseWS import basketball use_twisted() import random import redis start_logging(level='debug') import pandas as pd import sys class DiffusionClient(object): _USER_AGENT = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/5.0 (KHTML, like Gecko) Chrome/5.0 Safari/5.0' def __init__(self, connection_url, trigger, session_url=None, protocol=None, headers={}, topics=[]): self._message_handler = self self._connection_url = connection_url self._trigger = trigger self._session_url = session_url self._protocol = protocol