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()
