def _create_transport_serializers(transport): """ Create a list of serializers to use with a WAMP protocol factory. """ serializers = [] for serializer_id in transport.serializers: if serializer_id == u'msgpack': # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer except ImportError: pass else: serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) elif serializer_id == u'json': # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer except ImportError: pass else: serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) else: raise RuntimeError("Unknown serializer '{}'".format(serializer_id)) return serializers
def connect(factory, **kw): proto = factory.buildProtocol('boom') proto.makeConnection(Mock()) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = (b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a") proto.processHandshake() from autobahn.wamp import role subrole = role.RoleSubscriberFeatures() msg = Hello("realm", roles=dict(subscriber=subrole), authmethods=["anonymous"]) serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Abort(reason="wamp.error.no_auth_method") proto.onMessage(*serializer.serialize(msg)) proto.onClose(False, 100, "wamp.error.no_auth_method") return succeed(proto)
def _create_transport_serializers(transport_config): """ Create a list of serializers to use with a WAMP protocol factory. """ if u'serializers' in transport_config: serializer_ids = _unique_list(transport_config['serializers']) else: serializer_ids = [u'msgpack', u'json'] serializers = [] for serializer_id in serializer_ids: if serializer_id == u'msgpack': # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer except ImportError: pass else: serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) if serializer_id == u'json': # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer except ImportError: pass else: serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) return serializers
def _create_transport_serializer(serializer_id): if serializer_id in [u'msgpack', u'mgspack.batched']: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer except ImportError: pass else: if serializer_id == u'mgspack.batched': return MsgPackSerializer(batched=True) else: return MsgPackSerializer() if serializer_id in [u'json', u'json.batched']: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer except ImportError: pass else: if serializer_id == u'json.batched': return JsonSerializer(batched=True) else: return JsonSerializer() raise RuntimeError( 'could not create serializer for "{}"'.format(serializer_id))
def connect(factory, **kw): proto = factory.buildProtocol('boom') proto.makeConnection(Mock()) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = ( b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a" ) proto.processHandshake() from autobahn.wamp import role subrole = role.RoleSubscriberFeatures() msg = Hello(u"realm", roles=dict(subscriber=subrole), authmethods=[u"anonymous"]) serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Abort(reason=u"wamp.error.no_auth_method") proto.onMessage(*serializer.serialize(msg)) proto.onClose(False, 100, u"wamp.error.no_auth_method") return succeed(proto)
def __init__(self, factory, serializers=None): """ Ctor. :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializers: A list of WAMP serializers to use (or None for default serializers). Serializers must implement :class:`autobahn.wamp.interfaces.ISerializer`. :type serializers: list """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception(u'Could not import any WAMP serializer') self._serializers = {} for ser in serializers: self._serializers[ser.SERIALIZER_ID] = ser self._protocols = [u'wamp.2.{}'.format(ser.SERIALIZER_ID) for ser in serializers]
def __init__(self, factory, serializers=None): """ :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializers: A list of WAMP serializers to use (or ``None`` for all available serializers). :type serializers: list of objects implementing :class:`autobahn.wamp.interfaces.ISerializer` """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception("could not import any WAMP serializers") self._serializers = {} for ser in serializers: self._serializers[ser.RAWSOCKET_SERIALIZER_ID] = ser
def __init__(self, factory, serializers=None, debug_wamp=False): """ Ctor. :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializers: A list of WAMP serializers to use (or None for default serializers). Serializers must implement :class:`autobahn.wamp.interfaces.ISerializer`. :type serializers: list """ assert (callable(factory)) self._factory = factory self.debug_wamp = debug_wamp if serializers is None: serializers = [] # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: pass # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception("could not import any WAMP serializers") self._serializers = {} for ser in serializers: self._serializers[ser.SERIALIZER_ID] = ser self._protocols = [ "wamp.2.%s" % ser.SERIALIZER_ID for ser in serializers ]
def _connect(self): if self.client: self.logger.debug('already connected to broadcaster %s' % self.url) return broadcaster = self self.logger.debug('trying to connect to broadcaster %s' % self.url) class BroadcasterComponent(wamp.ApplicationSession): def onJoin(self, details): broadcaster.client = self broadcaster.onSessionOpen() def onDisconnect(self): broadcaster.logger.debug( "Disconnected from broadcaster at %s, will reconnect" % broadcaster.host) broadcaster.client = None component_config = types.ComponentConfig(realm="yadt") session_factory = wamp.ApplicationSessionFactory( config=component_config) session_factory.session = BroadcasterComponent serializers = [JsonSerializer()] transport_factory = websocket.WampWebSocketClientFactory( session_factory, serializers=serializers, url="ws://{0}:{1}/wamp".format(self.host, self.port), debug=False, debug_wamp=False) client = clientFromString(reactor, "tcp:{0}:{1}".format(self.host, self.port)) from functools import partial client.connect(transport_factory).addErrback( partial(broadcaster.logger.warning, "Could not connect to broadcaster at %s"))
def __init__(self, url, roles=DEFAULT_CLIENT_ROLES, realm='realm1', protocols=('wamp.2.json', ), serializer=JsonSerializer()): self.url = url self.protocols = protocols self.realm = realm self.roles = roles self.serializer = serializer self.ws = None self.need_stop = False self.connected = False self.handlers = { message.Welcome.MESSAGE_TYPE: self._on_welcome, message.Subscribed.MESSAGE_TYPE: self._on_subscribed, message.Event.MESSAGE_TYPE: self._on_event, } self.queue = {} self.subscriptions = {} self.on_welcome_callback = None
def __init__(self, factory, config): ## transport configuration self._config = config ## WAMP serializer ## serid = config.get('serializer', 'msgpack') if serid == 'json': ## try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: raise Exception("could not load WAMP-JSON serializer") elif serid == 'msgpack': ## try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False ## FIXME except ImportError: raise Exception("could not load WAMP-MsgPack serializer") else: raise Exception("invalid WAMP serializer '{}'".format(serid)) WampRawSocketClientFactory.__init__(self, factory, serializer)
def __init__(self, factory, config): # remember transport configuration # self._config = config # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if 'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if 'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME serializers.append(serializer) except ImportError: self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified: {}".format(sers)) else: serializers = None # Maximum message size # self._max_message_size = config.get('max_message_size', 128 * 1024) # default is 128kB rawsocket.WampRawSocketServerFactory.__init__(self, factory, serializers) self.log.debug( "RawSocket transport factory created using {serializers} serializers, max. message size {maxsize}", serializers=serializers, maxsize=self._max_message_size)
def __init__(self, factory, serializer=None): """ :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializer: The WAMP serializer to use (or ``None`` for "best" serializer, chosen as the first serializer available from this list: CBOR, MessagePack, UBJSON, JSON). :type serializer: object implementing :class:`autobahn.wamp.interfaces.ISerializer` """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializer is None: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializer = CBORSerializer() except ImportError: pass if serializer is None: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() except ImportError: pass if serializer is None: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializer = UBJSONSerializer() except ImportError: pass if serializer is None: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: pass if serializer is None: raise Exception("could not import any WAMP serializer") self._serializer = serializer
def __init__(self, factory, serializer=None): """ :param factory: A callable that produces instances that implement :class:`autobahn.wamp.interfaces.ITransportHandler` :type factory: callable :param serializer: The WAMP serializer to use (or None for default serializer). Serializers must implement :class:`autobahn.wamp.interfaces.ISerializer`. :type serializer: obj """ if callable(factory): self._factory = factory else: self._factory = lambda: factory if serializer is None: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializer = CBORSerializer() except ImportError: pass if serializer is None: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() except ImportError: pass if serializer is None: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializer = UBJSONSerializer() except ImportError: pass if serializer is None: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: pass if serializer is None: raise Exception("could not import any WAMP serializer") self._serializer = serializer
def connect(factory, **kw): proto = factory.buildProtocol('ws://localhost/') transport = FakeTransport() proto.makeConnection(transport) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = (b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a") proto.processHandshake() from autobahn.wamp import role features = role.RoleBrokerFeatures( publisher_identification=True, pattern_based_subscription=True, session_meta_api=True, subscription_meta_api=True, subscriber_blackwhite_listing=True, publisher_exclusion=True, subscription_revocation=True, payload_transparency=True, payload_encryption_cryptobox=True, ) msg = Welcome(123456, dict(broker=features), realm='realm') serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Goodbye() proto.onMessage(*serializer.serialize(msg)) proto.onClose(True, 100, "some old reason") return succeed(proto)
def connect(factory, **kw): proto = factory.buildProtocol('boom') proto.makeConnection(Mock()) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = ( b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a" ) proto.processHandshake() from autobahn.wamp import role features = role.RoleBrokerFeatures( publisher_identification=True, pattern_based_subscription=True, session_meta_api=True, subscription_meta_api=True, subscriber_blackwhite_listing=True, publisher_exclusion=True, subscription_revocation=True, payload_transparency=True, payload_encryption_cryptobox=True, ) msg = Welcome(123456, dict(broker=features), realm=u'realm') serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Goodbye() proto.onMessage(*serializer.serialize(msg)) proto.onClose(True, 100, "some old reason") return succeed(proto)
def __init__(self, factory, config): ## remember transport configuration ## self._config = config ## WAMP serializer ## serid = config.get('serializer', 'msgpack') if serid == 'json': ## try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: raise Exception("could not load WAMP-JSON serializer") elif serid == 'msgpack': ## try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False ## FIXME except ImportError: raise Exception("could not load WAMP-MsgPack serializer") else: raise Exception("invalid WAMP serializer '{}'".format(serid)) ## Maximum message size ## self._max_message_size = config.get('max_message_size', 128 * 1024) # default is 128kB ## transport debugging ## debug = config.get('debug', False) WampRawSocketServerFactory.__init__(self, factory, serializer, debug=debug) if self.debug: log.msg( "RawSocket transport factory created using {0} serializer, max. message size {1}" .format(serid, self._max_message_size))
def __init__(self, factory, config): # transport configuration self._config = config # WAMP serializer # serid = config.get(u'serializer', u'json') if serid == u'json': # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializer = JsonSerializer() except ImportError: raise Exception("could not load WAMP-JSON serializer") elif serid == u'msgpack': # try MessagePack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME except ImportError: raise Exception("could not load WAMP-MessagePack serializer") elif serid == u'cbor': # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializer = CBORSerializer() except ImportError: raise Exception("could not load WAMP-CBOR serializer") else: raise Exception("invalid WAMP serializer '{}'".format(serid)) rawsocket.WampRawSocketClientFactory.__init__(self, factory, serializer)
SessionKlass(types.ComponentConfig(realm=args.realm))) if args.transport == "websocket": ## create a WAMP-over-WebSocket transport server factory with longpoll fallback ## from autobahn.wamp.serializer import JsonSerializer, MsgPackSerializer from autobahn.twisted.websocket import WampWebSocketServerFactory from autobahn.twisted.resource import WebSocketResource from twisted.web.server import Site from twisted.web.static import File from autobahn.wamp.http import WampHttpResource ws_factory = WampWebSocketServerFactory(session_factory, debug_wamp=args.debug) ws_factory.setProtocolOptions(failByDrop=False) serializers = [MsgPackSerializer(), JsonSerializer()] resource = WampHttpResource(serializers, debug=True, timeout=100, killAfter=120) resource.factory = ws_factory root = File("longpoll") root.putChild("ws", WebSocketResource(ws_factory)) root.putChild("longpoll", resource) if args.static_dir: #root.putChild("web", File("/Users/arno/Documents/PycharmProjects/AutobahnJS/test/")) #root.putChild("autobahn.js", File("/Users/arno/Documents/PycharmProjects/AutobahnJS/build/autobahn.js")) #root.putChild("lib", File("/Users/arno/Documents/PycharmProjects/AutobahnJS/package/lib/")) root.putChild("static", File(args.static_dir))
def __init__(self, factory, serializers=None, timeout=10, killAfter=30, queueLimitBytes=128 * 1024, queueLimitMessages=100, debug_transport_id=None, reactor=None): """ Create new HTTP WAMP Web resource. :param factory: A (router) session factory. :type factory: Instance of :class:`autobahn.twisted.wamp.RouterSessionFactory`. :param serializers: List of WAMP serializers. :type serializers: list of obj (which implement :class:`autobahn.wamp.interfaces.ISerializer`) :param timeout: XHR polling timeout in seconds. :type timeout: int :param killAfter: Kill WAMP session after inactivity in seconds. :type killAfter: int :param queueLimitBytes: Kill WAMP session after accumulation of this many bytes in send queue (XHR poll). :type queueLimitBytes: int :param queueLimitMessages: Kill WAMP session after accumulation of this many message in send queue (XHR poll). :type queueLimitMessages: int :param debug: Enable debug logging. :type debug: bool :param debug_transport_id: If given, use this fixed transport ID. :type debug_transport_id: str :param reactor: The Twisted reactor to run under. :type reactor: obj """ Resource.__init__(self) # RouterSessionFactory self._factory = factory # lazy import to avoid reactor install upon module import if reactor is None: from twisted.internet import reactor self.reactor = reactor self._debug_transport_id = debug_transport_id self._timeout = timeout self._killAfter = killAfter self._queueLimitBytes = queueLimitBytes self._queueLimitMessages = queueLimitMessages if serializers is None: serializers = [] # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: pass # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: pass if not serializers: raise Exception("could not import any WAMP serializers") self._serializers = {} for ser in serializers: self._serializers[ser.SERIALIZER_ID] = ser self._transports = {} # <Base URL>/open # self.putChild(b"open", WampLongPollResourceOpen(self)) self.log.debug("WampLongPollResource initialized")
def test_minimal(self): embedded_components, client_components = [], [ Case2_Backend, Case2_Frontend ] ## create a WAMP router factory ## router_factory = RouterFactory() ## create a WAMP router session factory ## session_factory = RouterSessionFactory(router_factory) ## .. and create and add an WAMP application session to ## run next to the router ## config = types.ComponentConfig(realm=self.realm, extra={'caselog': 'case1.log'}) try: log = io.open('caselog.log', 'w') except Exception as e: print(e) return # log = io.open(config.extra['caselog'], 'w') config.log = log config.dlog = [] config.components = [] config.all_done = [] for C in embedded_components: one_done = Deferred() config.all_done.append(one_done) c = C(config, one_done) config.components.append(c) session_factory.add(c) if self.transport == "websocket": ## create a WAMP-over-WebSocket transport server factory ## transport_factory = WampWebSocketServerFactory( session_factory, debug_wamp=self.debug) transport_factory.setProtocolOptions(failByDrop=False, openHandshakeTimeout=0, closeHandshakeTimeout=0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport server factory ## if self.transport == 'rawsocket-msgpack': serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': serializer = JsonSerializer() else: raise Exception("should not arrive here") transport_factory = WampRawSocketServerFactory( session_factory, serializer, debug=self.debug) else: raise Exception("should not arrive here") ## start the server from an endpoint ## from twisted.internet import reactor server = serverFromString(reactor, self.server) d = server.listen(transport_factory) def onlisten(port): config.port = port d.addCallback(onlisten) clients = [] clients_d = [] for C in client_components: ## create a WAMP application session factory ## session_factory = ApplicationSessionFactory(config) one_done = Deferred() config.all_done.append(one_done) def make_make(Klass, done): def make(config): c = Klass(config, done) config.components.append(c) return c return make ## .. and set the session class on the factory ## session_factory.session = make_make(C, one_done) if self.transport == "websocket": serializers = [JsonSerializer()] ## create a WAMP-over-WebSocket transport client factory ## transport_factory = WampWebSocketClientFactory( session_factory, serializers=serializers, url=self.url, debug_wamp=self.debug) if True: def maker(Klass): class TestClientProtocol( WampWebSocketClientProtocol): def onOpen(self): self.txcnt = 0 self.rxcnt = 0 WampWebSocketClientProtocol.onOpen(self) def sendMessage(self, bytes, isBinary): self.txcnt += 1 print("> : {:>3} : {:<20} : {}".format( self.txcnt, Klass.__name__, bytes)) WampWebSocketClientProtocol.sendMessage( self, bytes, isBinary) def onMessage(self, bytes, isBinary): self.rxcnt += 1 print("< : {:>3} : {:<20} : {}".format( self.rxcnt, Klass.__name__, bytes)) WampWebSocketClientProtocol.onMessage( self, bytes, isBinary) return TestClientProtocol transport_factory.protocol = maker(C) else: transport_factory.protocol = WampWebSocketClientProtocol transport_factory.setProtocolOptions( failByDrop=False, openHandshakeTimeout=0, closeHandshakeTimeout=0) elif self.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport client factory ## if self.transport == 'rawsocket-msgpack': serializer = MsgPackSerializer() elif self.transport == 'rawsocket-json': serializer = JsonSerializer() else: raise Exception("should not arrive here") transport_factory = WampRawSocketClientFactory( session_factory, serializer, debug=self.debug) ## start the client from an endpoint ## cl = clientFromString(reactor, self.client) clients_d.append(cl.connect(transport_factory)) clients.append(cl) config.connected_clients = None def client_connected(res): config.connected_clients = [ proto for success, proto in res if success ] DeferredList(clients_d).addCallback(client_connected) d = DeferredList(config.all_done, consumeErrors=True) #d = config.components[1]._done def done(res): log.flush() log.close() if config.port: config.port.stopListening() if config.connected_clients: for proto in config.connected_clients: proto.transport.abortConnection() print("Log length: {}".format(len(config.dlog))) print(config.dlog) #from twisted.internet import reactor #reactor.callLater(1, reactor.stop) def error(err): print(err) d.addCallbacks(done, error) # d2 = Deferred() return d
subscriber.set_runner(runner) loop = asyncio.get_event_loop() try: session_factory = wamp.ApplicationSessionFactory() session_factory.session = WampComponent session_factory._myAppSession = None # TODO: should not be hardcoded but rather moved to setting file... url = "ws://127.0.0.1:31947/ws" serializers = [] serializers.append(JsonSerializer()) serializers.append(MsgPackSerializer()) transport_factory = websocket.WampWebSocketClientFactory( session_factory, url=url, serializers=serializers) subscriber = Subscriber(session_factory, loop) publisher = Publisher(session_factory) while (crossbar_status == False): try: logger.info('trying to make a connection...') make_a_connection() disconnect_counter = 0 except KeyboardInterrupt: crossbar_status = True
from dateutil.parser import parse import dateutil tz = dateutil.tz.tzlocal() sid = sys.argv[1] userId = sys.argv[2] date = parse(sys.argv[3]) start = parse(sys.argv[4]) end = parse(sys.argv[5]) dayOfWeek = sys.argv[6] dayOfMonth = sys.argv[7] dayOfYear = sys.argv[8] ret = yield from self.call('assistance.persistSchedule', sid, userId, date, start, end, dayOfWeek, dayOfMonth, dayOfYear) logging.debug(ret) sys.exit() if __name__ == '__main__': from autobahn.asyncio.wamp import ApplicationRunner from autobahn.wamp.serializer import JsonSerializer url = config.configs['server_url'] realm = config.configs['server_realm'] debug = config.configs['server_debug'] json = JsonSerializer() runner = ApplicationRunner(url=url, realm=realm, debug=debug, debug_wamp=debug, debug_app=debug, serializers=[json]) runner.run(WampMain)
def __init__(self, factory, cbdir, config, templates): """ :param factory: WAMP session factory. :type factory: An instance of .. :param cbdir: The Crossbar.io node directory. :type cbdir: str :param config: Crossbar transport configuration. :type config: dict :param templates: :type templates: """ self.debug_traffic = config.get('debug_traffic', False) options = config.get('options', {}) # announce Crossbar.io server version # self.showServerVersion = options.get('show_server_version', self.showServerVersion) if self.showServerVersion: server = "Crossbar/{}".format(crossbar.__version__) else: # do not disclose crossbar version server = "Crossbar" # external (public) listening port (eg when running behind a reverse proxy) # externalPort = options.get('external_port', None) # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if 'flatbuffers' in sers: # try FlatBuffers WAMP serializer try: from autobahn.wamp.serializer import FlatBuffersSerializer serializers.append(FlatBuffersSerializer(batched=True)) serializers.append(FlatBuffersSerializer()) except ImportError('FlatBuffersSerializer'): self.log.warn( "Warning: could not load WAMP-FlatBuffers serializer") else: sers.discard('flatbuffers') if 'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError('CBORSerializer'): self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard('cbor') if 'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError('MsgPackSerializer'): self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if 'ubjson' in sers: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError('UBJSONSerializer'): self.log.warn( "Warning: could not load WAMP-UBJSON serializer") else: sers.discard('ubjson') if 'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError('JsonSerializer'): self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None websocket.WampWebSocketServerFactory.__init__( self, factory, serializers=serializers, url=config.get('url', None), server=server, externalPort=externalPort) # Crossbar.io node directory self._cbdir = cbdir # transport configuration self._config = config # Jinja2 templates for 404 etc self._templates = templates # enable cookie tracking if a cookie store is configured if 'cookie' in config: # cookie store configuration item cookie_config = config['cookie'] # cookie store cookie_store_config = cookie_config['store'] cookie_store_type = cookie_store_config['type'] # setup ephemeral, memory-backed cookie store if cookie_store_type == 'memory': self._cookiestore = CookieStoreMemoryBacked(cookie_config) self.log.info("Memory-backed cookie store active.") # setup persistent, file-backed cookie store elif cookie_store_type == 'file': cookie_store_file = os.path.abspath( os.path.join(self._cbdir, cookie_store_config['filename'])) self._cookiestore = CookieStoreFileBacked( cookie_store_file, cookie_config) self.log.info( "File-backed cookie store active {cookie_store_file}", cookie_store_file=hlval(cookie_store_file)) # setup persistent, database-backed cookie store elif cookie_store_type == 'database': cookie_dbpath = os.path.abspath( os.path.join(self._cbdir, cookie_store_config['path'])) self._cookiestore = CookieStoreDatabaseBacked( cookie_dbpath, cookie_config) self.log.info( "Database-backed cookie store active! [cookiestore={cookiestore}]", cookiestore=hltype(CookieStoreDatabaseBacked)) else: # should not arrive here as the config should have been checked before raise NotImplementedError( '{}: implementation of cookiestore of type "{}" missing'. format(self.__class__.__name__, cookie_store_type)) else: # this disables cookie tracking (both with or without WAMP-cookie authentication) self._cookiestore = None # set WebSocket options set_websocket_options(self, options)
## from autobahn.twisted.websocket import WampWebSocketServerFactory transport_factory = WampWebSocketServerFactory(session_factory, debug_wamp=args.debug) transport_factory.setProtocolOptions(failByDrop=False) elif args.transport in ['rawsocket-json', 'rawsocket-msgpack']: ## create a WAMP-over-RawSocket transport server 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") from autobahn.twisted.rawsocket import WampRawSocketServerFactory transport_factory = WampRawSocketServerFactory(session_factory, serializer, debug=args.debug) else: raise Exception("should not arrive here") from autobahn.twisted.websocket import WampWebSocketClientFactory, WampWebSocketClientProtocol ## start the server from an endpoint ##
def __init__(self, factory, cbdir, config, templates): """ Ctor. :param factory: WAMP session factory. :type factory: An instance of .. :param cbdir: The Crossbar.io node directory. :type cbdir: str :param config: Crossbar transport configuration. :type config: dict """ self.debug = config.get('debug', False) self.debug_traffic = config.get('debug_traffic', False) options = config.get('options', {}) server = "Crossbar/{}".format(crossbar.__version__) externalPort = options.get('external_port', None) ## explicit list of WAMP serializers ## if 'serializers' in config: serializers = [] sers = set(config['serializers']) if 'json' in sers: ## try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer()) except ImportError: print("Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if 'msgpack' in sers: ## try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer()) except ImportError: print("Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified: {}".format(sers)) else: serializers = None WampWebSocketServerFactory.__init__(self, factory, serializers=serializers, url=config.get('url', None), server=server, externalPort=externalPort, debug=self.debug, debug_wamp=self.debug) ## Crossbar.io node directory self._cbdir = cbdir ## transport configuration self._config = config ## Jinja2 templates for 404 etc self._templates = templates ## cookie tracking if 'cookie' in config: if 'database' in config['cookie']: dbfile = os.path.abspath( os.path.join(self._cbdir, config['cookie']['database'])) self._cookiestore = PersistentCookieStore( dbfile, config['cookie']) log.msg("Persistent cookie store active: {}".format(dbfile)) else: self._cookiestore = CookieStore(config['cookie']) log.msg("Transient cookie store active.") else: self._cookiestore = None ## set WebSocket options set_websocket_options(self, options)
from autobahn.asyncio.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") from autobahn.asyncio.rawsocket import WampRawSocketClientFactory transport_factory = WampRawSocketClientFactory(session_factory, serializer, debug=args.debug) else: raise Exception("logic error") ## start the client loop = asyncio.get_event_loop() coro = loop.create_connection(transport_factory, args.host, args.port) loop.run_until_complete(coro)
def __init__(self, factory, cbdir, config, templates): """ Ctor. :param factory: WAMP session factory. :type factory: An instance of .. :param cbdir: The Crossbar.io node directory. :type cbdir: str :param config: Crossbar transport configuration. :type config: dict """ self.debug_traffic = config.get('debug_traffic', False) options = config.get('options', {}) self.showServerVersion = options.get('show_server_version', self.showServerVersion) if self.showServerVersion: server = "Crossbar/{}".format(crossbar.__version__) else: server = "Crossbar" externalPort = options.get('external_port', None) # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if u'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer(batched=True)) serializers.append(CBORSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard(u'cbor') if u'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializers.append(MsgPackSerializer(batched=True)) serializers.append(MsgPackSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if u'ubjson' in sers: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-UBJSON serializer") else: sers.discard(u'ubjson') if u'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer(batched=True)) serializers.append(JsonSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard(u'json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None websocket.WampWebSocketServerFactory.__init__( self, factory, serializers=serializers, url=config.get('url', None), server=server, externalPort=externalPort) # Crossbar.io node directory self._cbdir = cbdir # transport configuration self._config = config # Jinja2 templates for 404 etc self._templates = templates # cookie tracking if 'cookie' in config: cookie_store_type = config['cookie']['store']['type'] # ephemeral, memory-backed cookie store if cookie_store_type == 'memory': self._cookiestore = CookieStoreMemoryBacked(config['cookie']) self.log.info("Memory-backed cookie store active.") # persistent, file-backed cookie store elif cookie_store_type == 'file': cookie_store_file = os.path.abspath( os.path.join(self._cbdir, config['cookie']['store']['filename'])) self._cookiestore = CookieStoreFileBacked( cookie_store_file, config['cookie']) self.log.info( "File-backed cookie store active {cookie_store_file}", cookie_store_file=cookie_store_file) else: # should not arrive here as the config should have been checked before raise Exception("logic error") else: self._cookiestore = None # set WebSocket options set_websocket_options(self, options)
def __init__(self, factory, config): # remember transport configuration # self._config = config # explicit list of WAMP serializers # if 'serializers' in config: serializers = [] sers = set(config['serializers']) if 'flatbuffers' in sers: # try FlatBuffers WAMP serializer try: from autobahn.wamp.serializer import FlatBuffersSerializer serializers.append(FlatBuffersSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-FlatBuffers serializer") else: sers.discard('flatbuffers') if 'cbor' in sers: # try CBOR WAMP serializer try: from autobahn.wamp.serializer import CBORSerializer serializers.append(CBORSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-CBOR serializer") else: sers.discard('cbor') if 'msgpack' in sers: # try MsgPack WAMP serializer try: from autobahn.wamp.serializer import MsgPackSerializer serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME serializers.append(serializer) except ImportError: self.log.warn( "Warning: could not load WAMP-MsgPack serializer") else: sers.discard('msgpack') if 'ubjson' in sers: # try UBJSON WAMP serializer try: from autobahn.wamp.serializer import UBJSONSerializer serializers.append(UBJSONSerializer(batched=True)) serializers.append(UBJSONSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-UBJSON serializer") else: sers.discard('ubjson') if 'json' in sers: # try JSON WAMP serializer try: from autobahn.wamp.serializer import JsonSerializer serializers.append(JsonSerializer()) except ImportError: self.log.warn( "Warning: could not load WAMP-JSON serializer") else: sers.discard('json') if not serializers: raise Exception("no valid WAMP serializers specified") if len(sers) > 0: raise Exception( "invalid WAMP serializers specified (the following were unprocessed) {}" .format(sers)) else: serializers = None rawsocket.WampRawSocketServerFactory.__init__(self, factory, serializers) if 'options' in config: set_rawsocket_options(self, config['options']) self.log.debug( "RawSocket transport factory created using {serializers} serializers, max. message size {maxsize}", serializers=serializers, maxsize=self._max_message_size)