Beispiel #1
0
    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[:] = []
Beispiel #2
0
    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))])
Beispiel #3
0
 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)))
Beispiel #4
0
 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))])
Beispiel #5
0
    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))
Beispiel #6
0
 def test_dropping_all_exported_references(self):
     loop = self.make_event_loop()
     sock1, sock2 = self.socketpair()
     self.make_connection(loop, sock1, [cap.PlashObject()
                                        for index in range(100)])
     del sock1
     writer = plash.comms.stream.FDBufferedWriter(loop, sock2)
     for index in range(100):
         writer.write(plash.comms.simple.make_message(cap.make_drop_message(
                     cap.encode_wire_id(cap.NAMESPACE_RECEIVER, index))))
     loop.run_awhile()
     self.assertTrue(self._connection_dropped(sock2))
Beispiel #7
0
    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()
Beispiel #8
0
 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[:] = []
Beispiel #9
0
 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[:] = []
Beispiel #10
0
    def test_dropping_exported_references(self):
        deleted = []
        class Object(cap.PlashObject):
            def __init__(self, index):
                self._index = index
            def __del__(self):
                deleted.append(self._index)

        loop = self.make_event_loop()
        sock1, sock2 = self.socketpair()
        self.make_connection(loop, sock1, [Object(index)
                                           for index in range(100)])
        writer = plash.comms.stream.FDBufferedWriter(loop, sock2)
        # Should work for any sequence of indexes
        indexes = [5, 10, 56, 1, 0]
        for index in indexes:
            writer.write(plash.comms.simple.make_message(cap.make_drop_message(
                        cap.encode_wire_id(cap.NAMESPACE_RECEIVER, index))))
        loop.run_awhile()
        self.assertEquals(deleted, indexes)
Beispiel #11
0
 def test_id_encoding(self):
     args = (cap.NAMESPACE_SENDER, 12345)
     self.assertEquals(cap.decode_wire_id(cap.encode_wire_id(*args)), args)