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)) WampRawSocketServerFactory.__init__(self, factory, serializer)
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)) debug = config.get('debug', False) WampRawSocketServerFactory.__init__(self, factory, serializer, debug = debug)
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: 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 serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False # FIXME serializers.append(serializer) 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 # 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, serializers, debug=debug) if self.debug: log.msg("RawSocket transport factory created using {0} serializers, max. message size {1}".format(serializers, self._max_message_size))
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 test_handshake_succeeds(self): """ A client can connect to a server. """ session_mock = Mock() t = FakeTransport() f = WampRawSocketClientFactory(lambda: session_mock) p = WampRawSocketClientProtocol() p.transport = t p.factory = f server_session_mock = Mock() st = FakeTransport() sf = WampRawSocketServerFactory(lambda: server_session_mock) sp = WampRawSocketServerProtocol() sp.transport = st sp.factory = sf sp.connectionMade() p.connectionMade() # Send the server the client handshake sp.dataReceived(t._written[0:1]) sp.dataReceived(t._written[1:4]) # Send the client the server handshake p.dataReceived(st._written) # The handshake succeeds, a session on each end is created # onOpen is called on the session session_mock.onOpen.assert_called_once_with(p) server_session_mock.onOpen.assert_called_once_with(sp)
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 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
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 ## server = serverFromString(reactor, args.server) server.listen(transport_factory) clients = [] clients_d = [] for C in client_components:
## 1) create a WAMP router factory router_factory = RouterFactory() ## 2) create a WAMP router session factory session_factory = RouterSessionFactory(router_factory) ## 3) Optionally, add embedded WAMP application sessions to the router session_factory.add(MyBackendComponent()) ## 4) create a WAMP-over-WebSocket transport server factory transport_factory1 = WampWebSocketServerFactory(session_factory, debug=False) ## 5) start the server from a Twisted endpoint server1 = serverFromString(reactor, "tcp:8080") server1.listen(transport_factory1) ## 6) create a WAMP-over-RawSocket-MsgPack transport server factory serializer = MsgPackSerializer() serializer._serializer.ENABLE_V5 = False transport_factory2 = WampRawSocketServerFactory(session_factory, serializer, debug=True) ## 7) start the server from a Twisted endpoint server2 = serverFromString(reactor, "tcp:8090") server2.listen(transport_factory2) ## 8) now enter the Twisted reactor loop reactor.run()