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 __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 _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 _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 __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 RegisterWampClient(wampconf, secretfname):
WSClientConf = LoadWampClientConf(wampconf)
if not WSClientConf:
print(_("WAMP client connection not established!"))
return
WampSecret = LoadWampSecret(secretfname)
if WampSecret is not None:
WSClientConf["secret"] = WampSecret
# create a WAMP application session factory
component_config = types.ComponentConfig(realm=WSClientConf["realm"],
extra=WSClientConf)
session_factory = wamp.ApplicationSessionFactory(config=component_config)
session_factory.session = WampSession
# create a WAMP-over-WebSocket transport client factory
transport_factory = ReconnectingWampWebSocketClientFactory(
session_factory,
url=WSClientConf["url"],
serializers=[MsgPackSerializer()])
# start the client from a Twisted endpoint
conn = connectWS(transport_factory)
print(_("WAMP client connecting to :"), WSClientConf["url"])
return conn
def RegisterWampClient(wampconf):
WSClientConf = LoadWampClientConf(wampconf)
# start logging to console
# log.startLogging(sys.stdout)
# create a WAMP application session factory
component_config = types.ComponentConfig(realm=WSClientConf["realm"],
extra={"ID": WSClientConf["ID"]})
session_factory = wamp.ApplicationSessionFactory(config=component_config)
session_factory.session = WampSession
# create a WAMP-over-WebSocket transport client factory
transport_factory = ReconnectingWampWebSocketClientFactory(
session_factory,
url=WSClientConf["url"],
serializers=[MsgPackSerializer()],
debug=False,
debug_wamp=False)
# start the client from a Twisted endpoint
conn = connectWS(transport_factory)
print("WAMP client connecting to :", WSClientConf["url"])
return conn
def RegisterWampClient():
## start logging to console
# log.startLogging(sys.stdout)
# create a WAMP application session factory
component_config = types.ComponentConfig(
realm = realm,
extra = {"ID":ID})
session_factory = wamp.ApplicationSessionFactory(
config = component_config)
session_factory.session = WampSession
# create a WAMP-over-WebSocket transport client factory
transport_factory = WampWebSocketClientFactory(
session_factory,
url = url,
serializers = [MsgPackSerializer()],
debug = False,
debug_wamp = False)
# start the client from a Twisted endpoint
conn = connectWS(transport_factory)
confnodesroot.logger.write(_("WAMP connecting to URL : %s\n")%url)
return conn
def __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 RegisterWampClient(wampconf=None, wampsecret=None):
global _WampConf, _WampSecret
_WampConfDefault = os.path.join(WorkingDir, "wampconf.json")
_WampSecretDefault = os.path.join(WorkingDir, "wamp.secret")
# set config file path only if not already set
if _WampConf is None:
# default project's wampconf has precedance over commandline given
if os.path.exists(_WampConfDefault) or wampconf is None:
_WampConf = _WampConfDefault
else:
_WampConf = wampconf
WampClientConf = GetConfiguration()
# set secret file path only if not already set
if _WampSecret is None:
# default project's wamp secret also
# has precedance over commandline given
if os.path.exists(_WampSecretDefault):
_WampSecret = _WampSecretDefault
else:
_WampSecret = wampsecret
if _WampSecret is not None:
WampClientConf["secret"] = LoadWampSecret(_WampSecret)
else:
print(_("WAMP authentication has no secret configured"))
_WampSecret = _WampSecretDefault
if not WampClientConf["active"]:
print(_("WAMP deactivated in configuration"))
return
# create a WAMP application session factory
component_config = types.ComponentConfig(
realm=WampClientConf["realm"],
extra=WampClientConf)
session_factory = wamp.ApplicationSessionFactory(
config=component_config)
session_factory.session = WampSession
# create a WAMP-over-WebSocket transport client factory
ReconnectingWampWebSocketClientFactory(
component_config,
session_factory,
url=WampClientConf["url"],
serializers=[MsgPackSerializer()])
# start the client from a Twisted endpoint
if _transportFactory:
connectWS(_transportFactory)
print(_("WAMP client connecting to :"), WampClientConf["url"])
return True
else:
print(_("WAMP client can not connect to :"), WampClientConf["url"])
return False
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 __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
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
logger.info(
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)
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)
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)
# Check that the cyclic references have been restored
for employee in company.employees:
assert employee.company is company
reg = yield self.subscribe(on_event, TOPIC)
self.log.info('subscribed to topic {topic}: registration={reg}',
topic=TOPIC,
reg=reg)
company = Company(u'Crossbar.io GmbH')
company.add_employee(u'Tobias Oberstein', u'CEO')
company.add_employee(u'Alexander Goedde', u'CFO')
pub = yield self.publish(
TOPIC,
company,
options=PublishOptions(acknowledge=True, exclude_me=False),
)
self.log.info('event published: publication={pub}', pub=pub)
if __name__ == '__main__':
txaio.use_twisted()
txaio.start_logging(level='info')
msgpack = MsgPackSerializer() # required to send binary on Python 2
runner = ApplicationRunner(u'ws://localhost:8080/ws',
u'realm1',
serializers=[msgpack])
runner.run(MySession)
import sys
import binascii
import msgpack
import struct
from autobahn.wamp.serializer import MsgPackSerializer
from autobahn.wamp import message
from autobahn.wamp import role
serializer = MsgPackSerializer()
serializer._serializer.ENABLE_V5 = False
payload = sys.stdin.read()
print
print len(payload)
print binascii.hexlify(payload)
print
i = 0
while i < len(payload):
l = struct.unpack("!I", payload[i:i + 4])[0]
print "len = ", l
obj = serializer.unserialize(payload[i + 4:i + 4 + l])
print obj
i += 4 + l
except NameError:
# Define 'unicode' for Python 3
def unicode(s, *_):
return s
def to_unicode(s):
return unicode(s, "utf-8")
parser = argparse.ArgumentParser()
parser.add_argument("server_ip", type=to_unicode)
parser.add_argument("port", type=to_unicode)
parser.add_argument("realm", type=to_unicode)
parser.add_argument("key", type=to_unicode)
parser.add_argument("datapath", type=to_unicode)
args = parser.parse_args()
ai_sv = "rs://" + args.server_ip + ":" + args.port
ai_realm = args.realm
# create a Wamp session object
session = Component(ComponentConfig(ai_realm, {}))
# initialize the msgpack serializer
serializer = MsgPackSerializer()
# use Wamp-over-rawsocket
runner = ApplicationRunner(ai_sv, ai_realm, serializers=[serializer])
runner.run(session, auto_reconnect=True)
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)
import sys
import binascii
import msgpack
import struct
from autobahn.wamp.serializer import MsgPackSerializer
from autobahn.wamp import message
from autobahn.wamp import role
serializer = MsgPackSerializer()
serializer._serializer.ENABLE_V5 = False
payload = sys.stdin.read()
print
print len(payload)
print binascii.hexlify(payload)
print
i = 0
while i < len(payload):
l = struct.unpack("!I", payload[i:i+4])[0]
print "len = ", l
obj = serializer.unserialize(payload[i+4:i+4+l])
print obj
i += 4 + l