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()
