def test_parse_and_marshal(self): wmsg = [ message.Hello.MESSAGE_TYPE, u"realm1", { u'roles': { u'publisher': {} } } ] msg = message.Hello.parse(wmsg) self.assertIsInstance(msg, message.Hello) self.assertEqual(msg.realm, u"realm1") self.assertEqual(msg.roles, {u'publisher': role.RolePublisherFeatures()}) self.assertEqual(msg.marshal(), wmsg) wmsg = [ message.Hello.MESSAGE_TYPE, u"realm1", { u'roles': { u'publisher': { 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, { u'publisher': role.RolePublisherFeatures(subscriber_blackwhite_listing=True) }) self.assertEqual(msg.marshal(), wmsg)
def test_ctor(self): e = message.Hello(u"realm1", {u'publisher': role.RolePublisherFeatures()}) 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'publisher': {}}}) e = message.Hello( u"realm1", { u'publisher': role.RolePublisherFeatures(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'publisher': { u'features': { u'subscriber_blackwhite_listing': True } } } })
def test_parse_and_marshal(self): wmsg = [message.Hello.MESSAGE_TYPE, "realm1", {'roles': {'publisher': {}}}] msg = message.Hello.parse(wmsg) self.assertIsInstance(msg, message.Hello) self.assertEqual(msg.realm, "realm1") self.assertEqual(msg.roles, {'publisher': role.RolePublisherFeatures()}) self.assertEqual(msg.resumable, None) self.assertEqual(msg.marshal(), wmsg) wmsg = [message.Hello.MESSAGE_TYPE, "realm1", {'roles': {'publisher': {'features': {'subscriber_blackwhite_listing': True}}}}] msg = message.Hello.parse(wmsg) self.assertIsInstance(msg, message.Hello) self.assertEqual(msg.realm, "realm1") self.assertEqual(msg.roles, {'publisher': role.RolePublisherFeatures(subscriber_blackwhite_listing=True)}) self.assertEqual(msg.marshal(), wmsg) wmsg = [message.Hello.MESSAGE_TYPE, "realm1", {'roles': {'publisher': {}}, 'resumable': False}] msg = message.Hello.parse(wmsg) self.assertIsInstance(msg, message.Hello) self.assertEqual(msg.realm, "realm1") self.assertEqual(msg.roles, {'publisher': role.RolePublisherFeatures()}) self.assertEqual(msg.resumable, False) self.assertEqual(msg.marshal(), wmsg) wmsg = [message.Hello.MESSAGE_TYPE, "realm1", {'roles': {'publisher': {}}, 'resumable': True, 'resume-session': 1234, 'resume-token': "dsjgsg"}] msg = message.Hello.parse(wmsg) self.assertIsInstance(msg, message.Hello) self.assertEqual(msg.realm, "realm1") self.assertEqual(msg.roles, {'publisher': role.RolePublisherFeatures()}) self.assertEqual(msg.resumable, True) self.assertEqual(msg.resume_session, 1234) self.assertEqual(msg.resume_token, "dsjgsg") self.assertEqual(msg.marshal(), wmsg)
def join(self, realm, authmethods = None, authid = None): """ Implements :func:`autobahn.wamp.interfaces.ISession.join` """ if six.PY2 and type(realm) == str: realm = six.u(realm) if self._session_id: raise Exception("already joined") self._goodbye_sent = False roles = [ role.RolePublisherFeatures(), role.RoleSubscriberFeatures(), role.RoleCallerFeatures(), role.RoleCalleeFeatures() ] msg = message.Hello(realm, roles, authmethods, authid) self._realm = realm self._transport.send(msg)
def generate_test_messages(): """ List of WAMP test message used for serializers. Expand this if you add more options or messages. This list of WAMP message does not contain any binary app payloads! """ some_bytes = os.urandom(32) some_unicode = '\u3053\u3093\u306b\u3061\u306f\u4e16\u754c' some_uri = 'com.myapp.foobar' some_unicode_uri = 'com.myapp.\u4f60\u597d\u4e16\u754c.baz' some_args = [1, 2, 3, 'hello', some_bytes, some_unicode, {'foo': 23, 'bar': 'hello', 'baz': some_bytes, 'moo': some_unicode}] some_kwargs = {'foo': 23, 'bar': 'hello', 'baz': some_bytes, 'moo': some_unicode, 'arr': some_args} msgs = [ message.Hello("realm1", {'subscriber': role.RoleSubscriberFeatures()}), message.Hello("realm1", {'publisher': role.RolePublisherFeatures()}), message.Hello("realm1", {'caller': role.RoleCallerFeatures()}), message.Hello("realm1", {'callee': role.RoleCalleeFeatures()}), message.Hello("realm1", { 'subscriber': role.RoleSubscriberFeatures(), 'publisher': role.RolePublisherFeatures(), 'caller': role.RoleCallerFeatures(), 'callee': role.RoleCalleeFeatures(), }), message.Goodbye(), message.Yield(123456), message.Yield(123456, args=some_args), message.Yield(123456, args=[], kwargs=some_kwargs), message.Yield(123456, args=some_args, kwargs=some_kwargs), message.Yield(123456, progress=True), message.Interrupt(123456), message.Interrupt(123456, mode=message.Interrupt.KILL), message.Invocation(123456, 789123), message.Invocation(123456, 789123, args=some_args), message.Invocation(123456, 789123, args=[], kwargs=some_kwargs), message.Invocation(123456, 789123, args=some_args, kwargs=some_kwargs), message.Invocation(123456, 789123, timeout=10000), message.Result(123456), message.Result(123456, args=some_args), message.Result(123456, args=[], kwargs=some_kwargs), message.Result(123456, args=some_args, kwargs=some_kwargs), message.Result(123456, progress=True), message.Cancel(123456), message.Cancel(123456, mode=message.Cancel.KILL), message.Call(123456, some_uri), message.Call(123456, some_uri, args=some_args), message.Call(123456, some_uri, args=[], kwargs=some_kwargs), message.Call(123456, some_uri, args=some_args, kwargs=some_kwargs), message.Call(123456, some_uri, timeout=10000), message.Call(123456, some_unicode_uri), message.Call(123456, some_unicode_uri, args=some_args), message.Call(123456, some_unicode_uri, args=[], kwargs=some_kwargs), message.Call(123456, some_unicode_uri, args=some_args, kwargs=some_kwargs), message.Call(123456, some_unicode_uri, timeout=10000), message.Unregistered(123456), message.Unregister(123456, 789123), message.Registered(123456, 789123), message.Register(123456, some_uri), message.Register(123456, some_uri, match='prefix'), message.Register(123456, some_uri, invoke='roundrobin'), message.Register(123456, some_unicode_uri), message.Register(123456, some_unicode_uri, match='prefix'), message.Register(123456, some_unicode_uri, invoke='roundrobin'), message.Event(123456, 789123), message.Event(123456, 789123, args=some_args), message.Event(123456, 789123, args=[], kwargs=some_kwargs), message.Event(123456, 789123, args=some_args, kwargs=some_kwargs), message.Event(123456, 789123, publisher=300), message.Published(123456, 789123), message.Publish(123456, some_uri), message.Publish(123456, some_uri, args=some_args), message.Publish(123456, some_uri, args=[], kwargs=some_kwargs), message.Publish(123456, some_uri, args=some_args, kwargs=some_kwargs), message.Publish(123456, some_uri, exclude_me=False, exclude=[300], eligible=[100, 200, 300]), message.Publish(123456, some_unicode_uri), message.Publish(123456, some_unicode_uri, args=some_args), message.Publish(123456, some_unicode_uri, args=[], kwargs=some_kwargs), message.Publish(123456, some_unicode_uri, args=some_args, kwargs=some_kwargs), message.Publish(123456, some_unicode_uri, exclude_me=False, exclude=[300], eligible=[100, 200, 300]), message.Unsubscribed(123456), message.Unsubscribe(123456, 789123), message.Subscribed(123456, 789123), message.Subscribe(123456, some_uri), message.Subscribe(123456, some_uri, match=message.Subscribe.MATCH_PREFIX), message.Subscribe(123456, some_unicode_uri), message.Subscribe(123456, some_unicode_uri, match=message.Subscribe.MATCH_PREFIX), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=some_args), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=[], kwargs=some_kwargs), message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=some_args, kwargs=some_kwargs), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=some_args), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=[], kwargs=some_kwargs), message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=some_args, kwargs=some_kwargs), message.Result(123456), message.Result(123456, args=some_args), message.Result(123456, args=some_args, kwargs=some_kwargs), ] return [(False, msg) for msg in msgs]
def process_connect(self, packet): """ Process the initial Connect message from the MQTT client. This should return a pair `(accept_conn, session_present)`, where `accept_conn` is a return code: 0: connection accepted 1-5: connection refused (see MQTT spec 3.2.2.3) """ # Connect(client_id='paho/4E23D8C09DD9C6CF2C', # flags=ConnectFlags(username=False, # password=False, # will=False, # will_retain=False, # will_qos=0, # clean_session=True, # reserved=False), # keep_alive=60, # will_topic=None, # will_message=None, # username=None, # password=None) self.log.info( 'WampMQTTServerProtocol.process_connect(packet={packet})', packet=packet) # we don't support session resumption: https://github.com/crossbario/crossbar/issues/892 if not packet.flags.clean_session: self.log.warn( 'denying MQTT connect from {peer}, as the clients wants to resume a session (which we do not support)', peer=peer2str(self.transport.getPeer())) return succeed((1, False)) # we won't support QoS 2: https://github.com/crossbario/crossbar/issues/1046 if packet.flags.will and packet.flags.will_qos not in [0, 1]: self.log.warn( 'denying MQTT connect from {peer}, as the clients wants to provide a "last will" event with QoS {will_qos} (and we only support QoS 0/1 here)', peer=peer2str(self.transport.getPeer()), will_qos=packet.flags.will_qos) return succeed((1, False)) # this will be resolved when the MQTT connect handshake is completed self._waiting_for_connect = Deferred() roles = { "subscriber": role.RoleSubscriberFeatures(payload_transparency=True, pattern_based_subscription=True), "publisher": role.RolePublisherFeatures(payload_transparency=True, x_acknowledged_event_delivery=True) } realm = self.factory._options.get('realm', None) authmethods = [] authextra = { 'mqtt': { 'client_id': packet.client_id, 'will': bool(packet.flags.will), 'will_topic': packet.will_topic } } if ISSLTransport.providedBy(self.transport): authmethods.append("tls") if packet.username and packet.password: authmethods.append("ticket") msg = message.Hello(realm=realm, roles=roles, authmethods=authmethods, authid=packet.username, authextra=authextra) self._pw_challenge = packet.password else: authmethods.append("anonymous") msg = message.Hello(realm=realm, roles=roles, authmethods=authmethods, authid=packet.client_id, authextra=authextra) self._wamp_session.onMessage(msg) if packet.flags.will: # it's unclear from the MQTT spec whether a) the publication of the last will # is to happen in-band during "connect", and if it fails, deny the connection, # or b) the last will publication happens _after_ "connect", and the connection # succeeds regardless whether the last will publication succeeds or not. # # we opt for b) here! # @inlineCallbacks @self._waiting_for_connect.addCallback def process_will(res): self.log.info() payload_format, mapped_topic, options = yield self.factory.transform_mqtt( packet.will_topic, packet.will_message) request = util.id() msg = message.Call( request=request, procedure="wamp.session.add_testament", args=[ mapped_topic, options.get('args', None), options.get('kwargs', None), { # specifiy "retain" for when the testament (last will) # will be auto-published by the broker later 'retain': bool(packet.flags.will_retain) } ]) self._wamp_session.onMessage(msg) returnValue(res) return self._waiting_for_connect
def test_str(self): e = message.Hello(u"realm1", {u'publisher': role.RolePublisherFeatures()}) self.assertIsInstance(str(e), str)
serializer._serializer.ENABLE_V5 = False def send(msg): bytes, _ = serializer.serialize(msg) l = struct.pack("!I", len(bytes)) sys.stdout.write(l) sys.stdout.write(bytes) msgs = [] ## HELLO ## roles = [ role.RolePublisherFeatures(), role.RoleSubscriberFeatures(), role.RoleCallerFeatures(), role.RoleCalleeFeatures() ] msgs.append(message.Hello("foobar", roles)) ## CHALLENGE ## msgs.append(message.Challenge("cookie")) ## HEARTBEAT ## msgs.append(message.Heartbeat(3, 7, "throw me away"))
def process_connect(self, packet): self._waiting_for_connect = Deferred() roles = { u"subscriber": role.RoleSubscriberFeatures(payload_transparency=True), u"publisher": role.RolePublisherFeatures(payload_transparency=True, x_acknowledged_event_delivery=True) } # Will be autoassigned realm = None methods = [] if ISSLTransport.providedBy(self.transport): methods.append(u"tls") if packet.username and packet.password: methods.append(u"ticket") msg = message.Hello(realm=realm, roles=roles, authmethods=methods, authid=packet.username) self._pw_challenge = packet.password else: methods.append(u"anonymous") msg = message.Hello(realm=realm, roles=roles, authmethods=methods, authid=packet.client_id) self._wamp_session.onMessage(msg) if packet.flags.will: @self._waiting_for_connect.addCallback def process_will(res): akw = mqtt_payload_transform( self._wamp_session._router._mqtt_payload_format, packet.will_message) if not akw: # Drop it I guess :( return res args, kwargs = akw msg = message.Call( request=util.id(), procedure=u"wamp.session.add_testament", args=[ u".".join(tokenise_mqtt_topic(packet.will_topic)), args, kwargs, { "retain": bool(packet.flags.will_retain) } ]) self._wamp_session.onMessage(msg) return res return self._waiting_for_connect
def process_connect(self, packet): try: self.log.debug( 'WampMQTTServerProtocol.process_connect(packet={packet})', packet=packet) self._waiting_for_connect = Deferred() roles = { u"subscriber": role.RoleSubscriberFeatures(payload_transparency=True), u"publisher": role.RolePublisherFeatures(payload_transparency=True, x_acknowledged_event_delivery=True) } realm = self.factory._options.get('realm', None) methods = [] if ISSLTransport.providedBy(self.transport): methods.append(u"tls") if packet.username and packet.password: methods.append(u"ticket") msg = message.Hello(realm=realm, roles=roles, authmethods=methods, authid=packet.username) self._pw_challenge = packet.password else: methods.append(u"anonymous") msg = message.Hello(realm=realm, roles=roles, authmethods=methods, authid=packet.client_id) self._wamp_session.onMessage(msg) if packet.flags.will: @inlineCallbacks @self._waiting_for_connect.addCallback def process_will(res): payload_format, mapped_topic, options = yield self.factory.transform_mqtt( packet.will_topic, packet.will_message) request = util.id() msg = message.Call(request=request, procedure=u"wamp.session.add_testament", args=[ mapped_topic, options.get('args', None), options.get('kwargs', None), { 'retain': bool(packet.flags.will_retain) } ]) self._wamp_session.onMessage(msg) returnValue(res) return self._waiting_for_connect except: self.log.failure()