def call(self, procedure, *args, **kwargs):
"""
Implements :func:`autobahn.wamp.interfaces.ICaller.call`
"""
if six.PY2 and type(procedure) == str:
procedure = six.u(procedure)
assert(isinstance(procedure, six.text_type))
if not self._transport:
raise exception.TransportLost()
request = util.id()
if 'options' in kwargs and isinstance(kwargs['options'], types.CallOptions):
opts = kwargs.pop('options')
msg = message.Call(request, procedure, args = args, kwargs = kwargs, **opts.options)
else:
opts = None
msg = message.Call(request, procedure, args = args, kwargs = kwargs)
## FIXME
#def canceller(_d):
# cancel_msg = message.Cancel(request)
# self._transport.send(cancel_msg)
#d = Deferred(canceller)
d = self._create_future()
self._call_reqs[request] = d, opts
self._transport.send(msg)
return d
def test_ctor(self):
e = message.Call(123456, u'com.myapp.procedure1')
msg = e.marshal()
self.assertEqual(len(msg), 4)
self.assertEqual(msg[0], message.Call.MESSAGE_TYPE)
self.assertEqual(msg[1], 123456)
self.assertEqual(msg[2], {})
self.assertEqual(msg[3], u'com.myapp.procedure1')
e = message.Call(123456, u'com.myapp.procedure1', args = [1, 2, 3], kwargs = {u'foo': 23, u'bar': u'hello'})
msg = e.marshal()
self.assertEqual(len(msg), 6)
self.assertEqual(msg[0], message.Call.MESSAGE_TYPE)
self.assertEqual(msg[1], 123456)
self.assertEqual(msg[2], {})
self.assertEqual(msg[3], u'com.myapp.procedure1')
self.assertEqual(msg[4], [1, 2, 3])
self.assertEqual(msg[5], {u'foo': 23, u'bar': u'hello'})
e = message.Call(123456, u'com.myapp.procedure1', timeout = 10000)
msg = e.marshal()
self.assertEqual(len(msg), 4)
self.assertEqual(msg[0], message.Call.MESSAGE_TYPE)
self.assertEqual(msg[1], 123456)
self.assertEqual(msg[2], {u'timeout': 10000})
self.assertEqual(msg[3], u'com.myapp.procedure1')
def test_call_cancel_two_sessions(self):
"""
this has 2 different session using the same ID (42) for their Call
requests to confirm we deal with the fact that these IDs are
only unique per-session properly
"""
messages = []
def session_send(msg):
messages.append(msg)
session0 = mock.Mock()
session0._transport.send = session_send
session0._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
session1 = mock.Mock()
session1._transport.send = session_send
session1._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
dealer = self.router._dealer
dealer.attach(session0)
dealer.attach(session1)
def authorize(*args, **kwargs):
return defer.succeed({'allow': True, 'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session0,
message.Register(1, 'com.example.my.proc', 'exact', message.Register.INVOKE_SINGLE, 2))
registered_msg = messages[-1]
self.assertIsInstance(registered_msg, message.Registered)
# two calls outstanding to the endpoint, both happen to use
# the same ID (42) which is legal
dealer.processCall(session0, message.Call(42, 'com.example.my.proc', []))
invocation_msg0 = messages[-1]
self.assertIsInstance(invocation_msg0, message.Invocation)
dealer.processCall(session1, message.Call(42, 'com.example.my.proc', []))
invocation_msg1 = messages[-1]
self.assertIsInstance(invocation_msg1, message.Invocation)
# now, cancel the first session's call
dealer.processCancel(session0, message.Cancel(
42,
"kill",
))
# should receive an INTERRUPT from the dealer now (for the
# correct session only)
interrupt_msg0 = messages[-1]
self.assertIsInstance(interrupt_msg0, message.Interrupt)
self.assertEqual(interrupt_msg0.request, invocation_msg0.request)
dealer.processInvocationError(
session0, message.Error(message.Invocation.MESSAGE_TYPE, invocation_msg0.request, 'wamp.error.canceled'))
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!
"""
msgs = [
message.Hello(u"realm1", {u'subscriber': role.RoleSubscriberFeatures()}),
message.Goodbye(),
message.Yield(123456),
message.Yield(123456, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'}),
message.Yield(123456, args=[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', match=u'prefix'),
message.Register(123456, u'com.myapp.procedure1', invoke=u'roundrobin'),
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', exclude_me=False, exclude=[300], eligible=[100, 200, 300]),
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'})
]
return [(False, msg) for msg in msgs]
def call(self, procedure, *args, **kwargs):
"""
Implements :func:`autobahn.wamp.interfaces.ICaller.call`
"""
if six.PY2 and type(procedure) == str:
procedure = six.u(procedure)
assert (isinstance(procedure, six.text_type))
if not self._transport:
raise exception.TransportLost()
request_id = self._request_id_gen.next()
if 'options' in kwargs and isinstance(kwargs['options'],
types.CallOptions):
options = kwargs.pop('options')
msg = message.Call(request_id,
procedure,
args=args,
kwargs=kwargs,
**options.message_attr())
else:
options = None
msg = message.Call(request_id, procedure, args=args, kwargs=kwargs)
# FIXME
# def canceller(_d):
# cancel_msg = message.Cancel(request)
# self._transport.send(cancel_msg)
# d = Deferred(canceller)
on_reply = txaio.create_future()
self._call_reqs[request_id] = CallRequest(request_id, on_reply,
options)
try:
# Notes:
#
# * this might raise autobahn.wamp.exception.SerializationError
# when the user payload cannot be serialized
# * we have to setup a PublishRequest() in _publish_reqs _before_
# calling transpor.send(), because a mock- or side-by-side transport
# will immediately lead on an incoming WAMP message in onMessage()
#
self._transport.send(msg)
except:
if request_id in self._call_reqs:
del self._call_reqs[request_id]
raise
return on_reply
def test_unserialize(ser, runtime):
msg = message.Call(123456,
u'com.myapp.procedure1',
args=[1, 2, 3],
kwargs={
u'foo': 23,
u'bar': u'hello'
},
timeout=10000,
receive_progress=True)
# serialize the WAMP message
payload, is_binary = ser.serialize(msg)
total_cnt = 0
total_bytes = 0
started = time()
ended = started
while (ended - started) < runtime:
for i in range(100000):
# unserialize message
msg = ser.unserialize(payload, is_binary)
total_bytes += len(payload)
total_cnt += 1
ended = time()
return ended - started, total_bytes, total_cnt
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
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)
def test_call_cancel(self):
last_message = {'1': []}
def session_send(msg):
last_message['1'] = msg
session = mock.Mock()
session._transport.send = session_send
session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
dealer = self.router._dealer
dealer.attach(session)
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session, message.Register(
1,
u'com.example.my.proc',
u'exact',
message.Register.INVOKE_SINGLE,
1
))
registered_msg = last_message['1']
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(session, message.Call(
2,
u'com.example.my.proc',
[]
))
invocation_msg = last_message['1']
self.assertIsInstance(invocation_msg, message.Invocation)
dealer.processCancel(session, message.Cancel(
2
))
# should receive an INTERRUPT from the dealer now
interrupt_msg = last_message['1']
self.assertIsInstance(interrupt_msg, message.Interrupt)
self.assertEqual(interrupt_msg.request, invocation_msg.request)
dealer.processInvocationError(session, message.Error(
message.Invocation.MESSAGE_TYPE,
invocation_msg.request,
u'wamp.error.canceled'
))
call_error_msg = last_message['1']
self.assertIsInstance(call_error_msg, message.Error)
self.assertEqual(message.Call.MESSAGE_TYPE, call_error_msg.request_type)
self.assertEqual(u'wamp.error.canceled', call_error_msg.error)
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 test_call_cancel(self):
messages = []
def session_send(msg):
messages.append(msg)
session = mock.Mock()
session._transport.send = session_send
session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
dealer = self.router._dealer
dealer.attach(session)
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session, message.Register(
1,
u'com.example.my.proc',
u'exact',
message.Register.INVOKE_SINGLE,
1
))
registered_msg = messages[-1]
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(session, message.Call(
2,
u'com.example.my.proc',
[]
))
invocation_msg = messages[-1]
self.assertIsInstance(invocation_msg, message.Invocation)
dealer.processCancel(session, message.Cancel(
2
))
# we should receive an INTERRUPT from the dealer now -- note
# that our session is both the caller and the callee in this
# test, so we'll get an INTERRUPT *and* an ERROR -- in that
# order.
interrupt_msg = messages[-2]
self.assertIsInstance(interrupt_msg, message.Interrupt)
self.assertEqual(interrupt_msg.request, invocation_msg.request)
call_error_msg = messages[-1]
self.assertIsInstance(call_error_msg, message.Error)
self.assertEqual(message.Call.MESSAGE_TYPE, call_error_msg.request_type)
self.assertEqual(u'wamp.error.canceled', call_error_msg.error)
def test_call_timeout_with_callee_and_caller_support(self):
messages = []
def session_send(msg):
messages.append(msg)
session = ApplicationSession()
session._transport = mock.Mock()
session._transport.send = session_send
session._session_roles = {
'callee': role.RoleCalleeFeatures(call_canceling=True),
'caller': role.RoleCallerFeatures(call_canceling=True),
}
dealer = self.router._dealer
dealer.attach(session)
dealer._cancel_timers.call_later = mock.Mock()
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(
session,
message.Register(1, u'com.example.my.proc', u'exact',
message.Register.INVOKE_SINGLE, 1))
registered_msg = messages[-1]
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(
session, message.Call(
2,
u'com.example.my.proc',
[],
timeout=1,
))
invocation_msg = messages[-1]
self.assertIsInstance(invocation_msg, message.Invocation)
# induce a timeout
# get the last time-out that was added...
mc = dealer._cancel_timers.call_later.mock_calls[0]
timeout_fn = mc[1][1]
# ...and call it
timeout_fn()
# caller gets Error (should see it)
# callee gets Interrupt (should see it)
self.assertTrue(any(
isinstance(msg, message.Error) for msg in messages))
self.assertTrue(
any(isinstance(msg, message.Interrupt) for msg in messages))
def test_outstanding_invoke(self):
"""
When a call is pending and the callee goes away, it cancels the
in-flight call
"""
raise unittest.SkipTest('FIXME: Adjust unit test mocks #1567')
session = mock.Mock()
session._realm = 'realm1'
self.router.authorize = mock.Mock(
return_value=defer.succeed({
'allow': True,
'disclose': True
}))
rap = RouterApplicationSession(session, self.router_factory)
rap.send(message.Hello("realm1",
{'caller': role.RoleCallerFeatures()}))
rap.send(message.Register(1, 'foo'))
# we can retrieve the Registration via
# session.mock_calls[-1][1][0] if req'd
# re-set the authorize, as the Deferred from above is already
# used-up and it gets called again to authorize the Call
self.router.authorize = mock.Mock(
return_value=defer.succeed({
'allow': True,
'disclose': True
}))
rap.send(message.Call(42, 'foo'))
orig = rap.send
d = defer.Deferred()
rap.send(message.Goodbye())
def wrapper(*args, **kw):
d.callback(args[0])
return orig(*args, **kw)
rap.send = wrapper
# we can do this *after* the call to send() the Goodbye
# (above) because it takes a reactor-turn to actually
# process the cancel/errors etc -- hence the Deferred and
# yield in this test...
msg = yield d
self.assertEqual(42, msg.request)
self.assertEqual('wamp.error.canceled', msg.error)
def test_call_cancel_nonowned_call(self):
last_message = {'1': []}
def session_send(msg):
last_message['1'] = msg
session = mock.Mock()
session._transport.send = session_send
session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
dealer = self.router._dealer
dealer.attach(session)
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session, message.Register(
1,
u'com.example.my.proc',
u'exact',
message.Register.INVOKE_SINGLE,
1
))
registered_msg = last_message['1']
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(session, message.Call(
2,
u'com.example.my.proc',
[]
))
invocation_msg = last_message['1']
self.assertIsInstance(invocation_msg, message.Invocation)
bad_session = mock.Mock()
bad_session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
dealer.attach(bad_session)
def attempt_bad_cancel():
dealer.processCancel(bad_session, message.Cancel(
2
))
self.failUnlessRaises(ProtocolError, attempt_bad_cancel)
def test_caller_detach_interrupt_cancel_not_supported(self):
last_message = {'1': []}
def session_send(msg):
last_message['1'] = msg
session = mock.Mock()
session._transport.send = session_send
session._session_roles = {'callee': role.RoleCalleeFeatures()}
caller_session = mock.Mock()
dealer = self.router._dealer
dealer.attach(session)
dealer.attach(caller_session)
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session, message.Register(
1,
u'com.example.my.proc',
u'exact',
message.Register.INVOKE_SINGLE,
1
))
registered_msg = last_message['1']
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(caller_session, message.Call(
2,
u'com.example.my.proc',
[]
))
invocation_msg = last_message['1']
self.assertIsInstance(invocation_msg, message.Invocation)
dealer.detach(caller_session)
# reset recorded message to make sure we don't receive anything
last_message['1'] = None
# should NOT receive an INTERRUPT from the dealer now because we don't support cancellation
self.assertIsNone(last_message['1'])
def test_authorize_exception_call(self):
"""
When a dynamic authorizor throws an exception (during processCall)
we log it.
"""
raise unittest.SkipTest('FIXME: the mock may be wrong here ..')
the_exception = RuntimeError("authorizer bug")
def boom(*args, **kw):
raise the_exception
self.router._roles[u'test_role'].authorize = boom
class TestSession(ApplicationSession):
def __init__(self, *args, **kw):
super(TestSession, self).__init__(*args, **kw)
self._authrole = u'test_role'
self._transport = mock.MagicMock()
session0 = TestSession()
self.router._dealer._registration_map.add_observer(
session0, u'test.proc')
# okay, we have an authorizer that will always explode and a
# single procedure registered; when we call it, then
# on_authorize_error (in dealer.py) should get called and our
# error logged.
call = message.Call(
request=1234,
procedure=u'test.proc',
args=tuple(),
kwargs=dict(),
)
# this should produce an error -- however processCall doesn't
# itself return the Deferred, so we look for the side-effect
# -- the router should have tried to send a message.Error (and
# we should also have logged the error).
self.router._dealer.processCall(session0, call)
self.assertEqual(1, len(session0._transport.mock_calls))
call = session0._transport.mock_calls[0]
self.assertEqual('send', call[0])
# ensure we logged our error (flushLoggedErrors also causes
# trial to *not* fail the unit-test despite an error logged)
errors = self.flushLoggedErrors()
self.assertTrue(the_exception in [fail.value for fail in errors])
def test_call_cancel_without_callee_support(self):
last_message = {'1': []}
def session_send(msg):
last_message['1'] = msg
session = mock.Mock()
session._transport.send = session_send
session._session_roles = {'callee': role.RoleCalleeFeatures()}
dealer = self.router._dealer
dealer.attach(session)
def authorize(*args, **kwargs):
return defer.succeed({'allow': True, 'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session, message.Register(
1,
'com.example.my.proc',
'exact',
message.Register.INVOKE_SINGLE,
1
))
registered_msg = last_message['1']
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(session, message.Call(
2,
'com.example.my.proc',
[]
))
invocation_msg = last_message['1']
self.assertIsInstance(invocation_msg, message.Invocation)
dealer.processCancel(session, message.Cancel(
2
))
# set message to None to make sure that we get nothing back
last_message['1'] = None
# should NOT receive an INTERRUPT from the dealer now
interrupt_msg = last_message['1']
self.assertIsNone(interrupt_msg)
def test_caller_detach_interrupt_cancel_supported(self):
last_message = {'1': []}
def session_send(msg):
last_message['1'] = msg
session = mock.Mock()
session._transport.send = session_send
session._session_roles = {'callee': role.RoleCalleeFeatures(call_canceling=True)}
caller_session = mock.Mock()
dealer = self.router._dealer
dealer.attach(session)
dealer.attach(caller_session)
def authorize(*args, **kwargs):
return defer.succeed({'allow': True, 'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
dealer.processRegister(session, message.Register(
1,
'com.example.my.proc',
'exact',
message.Register.INVOKE_SINGLE,
1
))
registered_msg = last_message['1']
self.assertIsInstance(registered_msg, message.Registered)
dealer.processCall(caller_session, message.Call(
2,
'com.example.my.proc',
[]
))
invocation_msg = last_message['1']
self.assertIsInstance(invocation_msg, message.Invocation)
dealer.detach(caller_session)
# should receive an INTERRUPT from the dealer now
interrupt_msg = last_message['1']
self.assertIsInstance(interrupt_msg, message.Interrupt)
self.assertEqual(interrupt_msg.request, invocation_msg.request)
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)
def test_yield_on_unowned_invocation(self):
sessionMessages = {'1': None}
def session1send(msg):
sessionMessages['1'] = msg
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
session1 = mock.Mock()
session1._transport.send = session1send
session2 = mock.Mock()
dealer = self.router._dealer
dealer.attach(session1)
dealer.attach(session2)
register = message.Register(1, u'com.example.some.call', u'exact',
message.Register.INVOKE_SINGLE, 1)
dealer.processRegister(session1, register)
registered = sessionMessages['1']
self.assertIsInstance(registered, message.Registered)
call = message.Call(2, u'com.example.some.call', [], {})
dealer.processCall(session1, call)
invocation = sessionMessages['1']
self.assertIsInstance(invocation, message.Invocation)
yieldMsg = message.Yield(invocation.request, [u'hello'], {})
# this yield is happening on a different session than the one that
# just received the invocation
def yield_from_wrong_session():
dealer.processYield(session2, yieldMsg)
self.failUnlessRaises(ProtocolError, yield_from_wrong_session)
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 test_concurrency_with_error(self):
"""
register a concurrency=2 method, called with errors
"""
callee_messages = []
caller_messages = []
def callee_send(msg):
callee_messages.append(msg)
session = mock.Mock()
session._transport.send = callee_send
session._session_roles = {'callee': role.RoleCalleeFeatures()}
def caller_send(msg):
caller_messages.append(msg)
caller_session = mock.Mock()
caller_session._transport.send = caller_send
dealer = self.router._dealer
dealer.attach(session)
dealer.attach(caller_session)
def authorize(*args, **kwargs):
return defer.succeed({u'allow': True, u'disclose': False})
self.router.authorize = mock.Mock(side_effect=authorize)
# we register out procedure, with concurrency=1
dealer.processRegister(
session,
message.Register(request=1,
procedure=u'com.example.my.proc',
match=u'exact',
invoke=message.Register.INVOKE_SINGLE,
concurrency=1))
registered_msg = callee_messages[-1]
self.assertIsInstance(registered_msg, message.Registered)
# we have registered our procedure that has concurrency=1
# and now we call it
dealer.processCall(caller_session,
message.Call(2, u'com.example.my.proc', []))
# we pretend that the call caused an error of some sort
invocation_msg = callee_messages[-1]
self.assertIsInstance(invocation_msg, message.Invocation)
dealer.processInvocationError(
session,
message.Error(
message.Call.MESSAGE_TYPE,
invocation_msg.request,
u"wamp.error.foo",
))
self.assertEqual(1, len(caller_messages))
self.assertEqual(
u"wamp.error.foo",
caller_messages[-1].error,
)
# now we call it again, which should work because the
# previously-outstanding call was resolved with an error
# (before bug 1105 being fixed this wouldn't work properly)
dealer.processCall(caller_session,
message.Call(3, u'com.example.my.proc', ['foo']))
invocation_msg = callee_messages[-1]
self.assertIsInstance(invocation_msg, message.Invocation)
self.assertEqual(1, len(caller_messages),
"got an extra unexpected message")
dealer.processYield(
session, message.Yield(
invocation_msg.request,
args=['a result'],
))
result_msg = caller_messages[-1]
self.assertIsInstance(result_msg, message.Result)
self.assertEqual(result_msg.args, ['a result'])
default=1000000,
help='Number of serializations/unserializations nto perform per round')
options = parser.parse_args()
SERMAP = {
'json': JsonObjectSerializer,
'msgpack': MsgPackObjectSerializer,
'cbor': CBORObjectSerializer
}
ser = SERMAP[options.serializer]()
msg = message.Call(1,
u'com.example.add2',
args=(1, 2),
kwargs={
u'foo': 23,
u'bar': u'baz'
},
receive_progress=True)
obj = msg.marshal()
if options.mode == 'ser':
print("testing serializing using {}".format(ser.__class__))
ops = test_serialize(options.count, options.rounds, ser, obj)
elif options.mode == 'unser':
print("testing unserializing using {}".format(ser.__class__))
ops = test_unserialize(options.count, options.rounds, ser, obj)
else:
raise Exception("logic error")
# arithmetic mean over second half of results for individual rounds
