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_receiving_references(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])
writer = plash.comms.stream.FDBufferedWriter(loop, sock2)
# Should work for any sequence of indexes
indexes = [6, 2, 52, 8, 4]
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, index)
for index in indexes],
"body data")))
loop.run_awhile()
self.assertEquals(len(calls), 1)
data, caps, fds = calls[0]
self.assertEquals(len(caps), len(indexes))
# Check internal state of received proxy objects
for index, received_obj in zip(indexes, caps):
assert isinstance(received_obj, self.base_class), received_obj
self.check_remote_object(received_obj, object_id=index,
single_use=False)
# Break "distributed" cycle: The connection refers to the
# "exported" object, which refers to imported objects via
# "calls", which refer to the connection.
calls[:] = []
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_receiving(self):
loop = self.make_event_loop()
sock1, sock2 = self.socketpair()
exported_objects = [CallLogger() for i in range(10)]
self.make_connection(loop, sock1, exported_objects)
writer = plash.comms.stream.FDBufferedWriter(loop, sock2)
# Should work for any sequence of valid indexes
for index in (0, 0, 1, 2):
writer.write(
plash.comms.simple.make_message(cap.make_invoke_message(
cap.encode_wire_id(cap.NAMESPACE_RECEIVER, index),
[], "body data")))
loop.run_awhile()
self.assertEquals(exported_objects[index].calls,
[("cap_invoke", (("body data", (), ()),))])
exported_objects[index].calls[:] = []
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_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)
