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)