def test_receiving_references_preserves_eq(self):
calls = []
class Object(cap.PlashObject):
def cap_invoke(self, args):
calls.append(args)
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
self.make_connection(loop, sock1, [Object()])
got = self._read_to_list(loop, sock2)
writer = plash.comms.stream.FDBufferedWriter(loop, sock2)
writer.write(plash.comms.simple.make_message(
cap.make_invoke_message(
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0),
[cap.encode_wire_id(cap.NAMESPACE_SENDER, 123),
cap.encode_wire_id(cap.NAMESPACE_SENDER, 123),
cap.encode_wire_id(cap.NAMESPACE_SENDER, 456)], "body")))
loop.run_awhile()
self.assertEquals(len(calls), 1)
data, caps, fds = calls[0]
self.assertEquals(caps[0], caps[1])
self.assertNotEquals(caps[1], caps[2])
# Now check that we get the right number of "drop" messages
del caps
calls[:] = []
loop.run_awhile()
decoded = [cap.decode_pocp_message(data) for data in got]
self.assertEquals(
sorted(decoded),
[("drop", cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 123)),
("drop", cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 123)),
("drop", cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 456))])
def test_sending_references_preserves_eq(self):
calls = []
class Object(cap.PlashObject):
def cap_invoke(self, args):
calls.append(args)
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
got = self._read_to_list(loop, sock1)
[imported] = self.make_connection(loop, sock2, [], 1)
writer = plash.comms.stream.FDBufferedWriter(loop, sock1)
object1 = Object()
object2 = Object()
imported.cap_invoke(("body", (object1, object1, object2), ()))
loop.run_awhile()
decoded = [cap.decode_pocp_message(data) for data in got]
self.assertEquals(
decoded, [("invoke", cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0),
[cap.encode_wire_id(cap.NAMESPACE_SENDER, 0),
cap.encode_wire_id(cap.NAMESPACE_SENDER, 0),
cap.encode_wire_id(cap.NAMESPACE_SENDER, 1)], "body")])
# Now check that we can invoke the resulting object and drop
# it twice
for unused in range(2):
writer.write(plash.comms.simple.make_message(
cap.make_invoke_message(
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0),
[], "body")))
writer.write(plash.comms.simple.make_message(
cap.make_drop_message(
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0))))
loop.run_awhile()
def test_dropping_imported_references(self):
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
got = self._read_to_list(loop, sock1)
imported_objects = list(self.make_connection(loop, sock2, [], 100))
imported_objects[42] = None
loop.run_awhile()
decoded = [cap.decode_pocp_message(data) for data in got]
self.assertEquals(
decoded,
[("drop", cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 42))])
def test_dropping_all_imported_references(self):
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
got = self._read_to_list(loop, sock1)
imported_objects = self.make_connection(loop, sock2, [], 1)
del sock2
del imported_objects
loop.run_awhile()
self.assertTrue(self._connection_dropped(sock1))
decoded = [cap.decode_pocp_message(data) for data in got]
# The last "drop" message is unnecessary and we should not
# receive it, because the connection will be dropped instead.
self.assertEquals(decoded, [])
def test_sending(self):
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
got = self._read_to_list(loop, sock1)
imported_objects = self.make_connection(loop, sock2, [], 10)
# Should work for any sequence of valid indexes
for index in (0, 0, 1, 2):
imported_objects[index].cap_invoke(("body data", (), ()))
loop.run_awhile()
decoded = [cap.decode_pocp_message(data) for data in got]
self.assertEquals(
decoded, [("invoke",
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, index),
[], "body data")])
got[:] = []
def test_sending_references(self):
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
got = self._read_to_list(loop, sock1)
[imported] = self.make_connection(loop, sock2, [], 1)
arg_objects = [cap.PlashObject() for i in range(10)]
imported.cap_invoke(("body", tuple(arg_objects), ()))
loop.run_awhile()
decoded = [cap.decode_pocp_message(data) for data in got]
self.assertEquals(
decoded, [("invoke",
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0),
[cap.encode_wire_id(cap.NAMESPACE_SENDER, index)
for index in range(10)], "body")])
# Check internal state of the connection
self.check_exports(
imported,
dict((index, arg_objects[index]) for index in range(10)))
def test_receiving_and_invoking_single_use_reference(self):
calls = []
class Object(cap.PlashObject):
def cap_invoke(self, args):
calls.append(args)
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
exported = Object()
self.make_connection(loop, sock1, [exported])
del sock1
received = self._read_to_list(loop, sock2)
writer = plash.comms.stream.FDBufferedWriter(loop, sock2)
writer.write(plash.comms.simple.make_message(cap.make_invoke_message(
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0),
[cap.encode_wire_id(cap.NAMESPACE_SENDER_SINGLE_USE, 1234)],
"body data")))
# Drop the exported object so that the imported single use
# object is the only one left.
writer.write(plash.comms.simple.make_message(cap.make_drop_message(
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 0))))
loop.run_awhile()
self.assertEquals(len(calls), 1)
data, caps, fds = calls[0]
[received_obj] = caps
assert isinstance(received_obj, self.base_class), received_obj
self.check_remote_object(received_obj, object_id=1234, single_use=True)
self.check_object_used_up(received_obj, used_up=False)
received_obj.cap_invoke(("some return message", (), ()))
self.check_object_used_up(received_obj, used_up=True)
# This tests sending a message and immediately disconnecting.
# The message should be queued, not dropped. The message
# should be sent before the connection is dropped.
loop.run_awhile()
decoded = [cap.decode_pocp_message(data) for data in received]
self.assertEquals(
decoded,
[("invoke", cap.encode_wire_id(cap.NAMESPACE_RECEIVER, 1234),
[], "some return message")])
self.assertTrue(self._connection_dropped(sock2))
def test_drop_encoding(self):
self.assertEquals(
cap.decode_pocp_message(cap.make_drop_message(789)),
("drop", 789))
def test_invoke_encoding(self):
invoke_args = (123, [4, 5, 6], "body")
self.assertEquals(
cap.decode_pocp_message(cap.make_invoke_message(*invoke_args)),
("invoke",) + invoke_args)
