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)
