def test_parse_and_marshal(self):
wmsg = [
message.Hello.MESSAGE_TYPE, u"realm1", {
u'roles': {
u'broker': {}
}
}
]
msg = message.Hello.parse(wmsg)
self.assertIsInstance(msg, message.Hello)
self.assertEqual(msg.realm, u"realm1")
self.assertEqual(msg.roles, [role.RoleBrokerFeatures()])
self.assertEqual(msg.marshal(), wmsg)
wmsg = [
message.Hello.MESSAGE_TYPE, u"realm1", {
u'roles': {
u'broker': {
u'features': {
u'subscriber_blackwhite_listing': True
}
}
}
}
]
msg = message.Hello.parse(wmsg)
self.assertIsInstance(msg, message.Hello)
self.assertEqual(msg.realm, u"realm1")
self.assertEqual(
msg.roles,
[role.RoleBrokerFeatures(subscriber_blackwhite_listing=True)])
self.assertEqual(msg.marshal(), wmsg)
def test_ctor(self):
e = message.Hello(u"realm1", [role.RoleBrokerFeatures()])
msg = e.marshal()
self.assertEqual(len(msg), 3)
self.assertEqual(msg[0], message.Hello.MESSAGE_TYPE)
self.assertEqual(msg[1], u"realm1")
self.assertEqual(msg[2], {u'roles': {u'broker': {}}})
e = message.Hello(
u"realm1",
[role.RoleBrokerFeatures(subscriber_blackwhite_listing=True)])
msg = e.marshal()
self.assertEqual(len(msg), 3)
self.assertEqual(msg[0], message.Hello.MESSAGE_TYPE)
self.assertEqual(msg[1], u"realm1")
self.assertEqual(
msg[2], {
u'roles': {
u'broker': {
u'features': {
u'subscriber_blackwhite_listing': True
}
}
}
})
def create_mock_welcome():
return message.Welcome(
1234,
{
'broker': role.RoleBrokerFeatures(),
},
)
def __init__(self, router, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`autobahn.wamp.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`autobahn.wamp.types.RouterOptions`.
"""
self._router = router
self._options = options or types.RouterOptions()
## map: session -> set(subscription)
## needed for removeSession
self._session_to_subscriptions = {}
## map: session_id -> session
## needed for exclude/eligible
self._session_id_to_session = {}
## map: topic -> (subscription, set(session))
## needed for PUBLISH and SUBSCRIBE
self._topic_to_sessions = {}
## map: subscription -> (topic, set(session))
## needed for UNSUBSCRIBE
self._subscription_to_sessions = {}
## check all topic URIs with strict rules
self._option_uri_strict = self._options.uri_check == types.RouterOptions.URI_CHECK_STRICT
## supported features from "WAMP Advanced Profile"
self._role_features = role.RoleBrokerFeatures(
publisher_identification=True,
subscriber_blackwhite_listing=True,
publisher_exclusion=True)
def __init__(self, router, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`crossbar.router.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`crossbar.router.types.RouterOptions`.
"""
self._router = router
self._options = options or RouterOptions()
# subscription map managed by this broker
self._subscription_map = UriObservationMap()
# map: session -> set of subscriptions (needed for detach)
self._session_to_subscriptions = {}
# check all topic URIs with strict rules
self._option_uri_strict = self._options.uri_check == RouterOptions.URI_CHECK_STRICT
# supported features from "WAMP Advanced Profile"
self._role_features = role.RoleBrokerFeatures(publisher_identification=True,
pattern_based_subscription=True,
subscription_meta_api=True,
subscriber_blackwhite_listing=True,
publisher_exclusion=True,
subscription_revocation=True)
def __init__(self, handler):
self._log = False
self._handler = handler
self._serializer = serializer.JsonSerializer()
self._registrations = {}
self._invocations = {}
self._subscription_topics = {}
self._my_session_id = util.id()
self._handler.onOpen(self)
roles = {u'broker': role.RoleBrokerFeatures(), u'dealer': role.RoleDealerFeatures()}
msg = message.Welcome(self._my_session_id, roles)
self._handler.onMessage(msg)
def __init__(self, router, reactor, options=None):
"""
:param router: The router this dealer is part of.
:type router: Object that implements :class:`crossbar.router.interfaces.IRouter`.
:param options: Router options.
:type options: Instance of :class:`crossbar.router.types.RouterOptions`.
"""
self._router = router
self._reactor = reactor
self._options = options or RouterOptions()
# generator for WAMP request IDs
self._request_id_gen = util.IdGenerator()
# subscription map managed by this broker
self._subscription_map = UriObservationMap()
# map: session -> set of subscriptions (needed for detach)
self._session_to_subscriptions = {}
# check all topic URIs with strict rules
self._option_uri_strict = self._options.uri_check == RouterOptions.URI_CHECK_STRICT
# supported features from "WAMP Advanced Profile"
self._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,
event_retention=True,
payload_transparency=True,
payload_encryption_cryptobox=True)
# store for event history
if self._router._store:
self._event_store = self._router._store.event_store
else:
self._event_store = None
# if there is a store, let the store attach itself to all the subscriptions
# it is configured to track
if self._event_store:
self._event_store.attach_subscription_map(self._subscription_map)
def generate_test_messages():
return [
message.Hello(u"realm1", [role.RoleBrokerFeatures()]),
message.Goodbye(),
message.Heartbeat(123, 456),
message.Yield(123456),
message.Yield(123456, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Yield(123456, progress = True),
message.Interrupt(123456),
message.Interrupt(123456, mode = message.Interrupt.KILL),
message.Invocation(123456, 789123),
message.Invocation(123456, 789123, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Invocation(123456, 789123, timeout = 10000),
message.Result(123456),
message.Result(123456, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Result(123456, progress = True),
message.Cancel(123456),
message.Cancel(123456, mode = message.Cancel.KILL),
message.Call(123456, u'com.myapp.procedure1'),
message.Call(123456, u'com.myapp.procedure1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Call(123456, u'com.myapp.procedure1', timeout = 10000),
message.Unregistered(123456),
message.Unregister(123456, 789123),
message.Registered(123456, 789123),
message.Register(123456, u'com.myapp.procedure1'),
message.Register(123456, u'com.myapp.procedure1', pkeys = [10, 11, 12]),
message.Event(123456, 789123),
message.Event(123456, 789123, args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Event(123456, 789123, publisher = 300),
message.Published(123456, 789123),
message.Publish(123456, u'com.myapp.topic1'),
message.Publish(123456, u'com.myapp.topic1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Publish(123456, u'com.myapp.topic1', excludeMe = False, exclude = [300], eligible = [100, 200, 300], discloseMe = True),
message.Unsubscribed(123456),
message.Unsubscribe(123456, 789123),
message.Subscribed(123456, 789123),
message.Subscribe(123456, u'com.myapp.topic1'),
message.Subscribe(123456, u'com.myapp.topic1', match = message.Subscribe.MATCH_PREFIX),
message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1'),
message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'}),
message.Call(123456, u'com.myapp.\u4f60\u597d\u4e16\u754c', args=[1, 2, 3]),
message.Result(123456, args=[1, 2, 3], kwargs={u'en': u'Hello World', u'jp': u'\u3053\u3093\u306b\u3061\u306f\u4e16\u754c'})
]
def __init__(self, handler):
self._log = False
self._handler = handler
self._serializer = serializer.JsonSerializer()
self._registrations = {}
self._invocations = {}
#: str -> ID
self._subscription_topics = {}
self._handler.onOpen(self)
self._my_session_id = util.id()
roles = {'broker': role.RoleBrokerFeatures(), 'dealer': role.RoleDealerFeatures()}
msg = message.Welcome(self._my_session_id, roles)
self._handler.onMessage(msg)
self._fake_router_session = ApplicationSession()
self._transport_details = TransportDetails()
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 test_str(self):
e = message.Hello(u"realm1", [role.RoleBrokerFeatures()])
self.assertIsInstance(str(e), str)
