Ejemplo n.º 1
0
    def test_downed_recipient_cancels_the_hub_sender_during_chunked_request(self):
        port = _free_port()
        hub = junction.Hub(("127.0.0.1", port), [])
        triggered = [False]

        @hub.accept_rpc('service', 0, 0, 'method')
        def handle(chunks):
            for item in chunks:
                pass
            return "all done"

        hub.start()

        port2 = _free_port()
        hub2 = junction.Hub(("127.0.0.1", port2), [("127.0.0.1", port)])
        hub2.start()
        hub2.wait_connected()

        def gen():
            try:
                while 1:
                    yield None
                    backend.pause_for(TIMEOUT)
            finally:
                triggered[0] = True

        rpc = hub2.send_rpc('service', 0, 'method', (gen(),))

        hub = [hub]
        backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub,))

        backend.pause_for(TIMEOUT * 5)

        assert triggered[0]
Ejemplo n.º 2
0
    def test_unrelated_rpcs_are_unaffected(self):
        hub = junction.Hub(("127.0.0.1", _free_port()), [])

        @hub.accept_rpc('service', 0, 0, 'method')
        def handle():
            backend.pause_for(TIMEOUT)
            return 1

        hub.start()

        peer = junction.Hub(("127.0.0.1", _free_port()), [hub.addr])
        peer.start()
        peer.wait_connected()

        client = junction.Client(hub.addr)
        client.connect()
        client.wait_connected()
        client = [client]

        backend.schedule(self.kill_client, (client,))

        # hub does a self-rpc during which the client connection goes away
        result = peer.rpc('service', 0, 'method')

        self.assertEqual(result, 1)
Ejemplo n.º 3
0
    def test_downed_hub_during_chunk_pub_to_client_terminates_correctly(self):
        port = _free_port()
        hub = junction.Hub(("127.0.0.1", port), [])
        l = []
        ev = backend.Event()

        @hub.accept_publish('service', 0, 0, 'method')
        def handle(x):
            for item in x:
                l.append(item)
            ev.set()

        hub.start()

        client = junction.Client(("127.0.0.1", port))
        client.connect()
        client.wait_connected()
        client = [client]

        def gen():
            yield 1
            yield 2
            self.kill_client(client)

        client[0].publish('service', 0, 'method', (gen(),))
        ev.wait(TIMEOUT)

        self.assertEqual(l[:2], [1,2])
        self.assertEqual(len(l), 3)
        self.assertIsInstance(l[-1], junction.errors.LostConnection)
Ejemplo n.º 4
0
    def test_unrelated_self_rpcs_are_unaffected(self):
        hub = junction.Hub(("127.0.0.1", _free_port()), [])

        @hub.accept_rpc('service', 0, 0, 'method')
        def handle():
            backend.pause_for(TIMEOUT)
            return 1

        hub.start()

        client = junction.Client(hub.addr)
        client.connect()
        client.wait_connected()
        client = [client]

        @backend.schedule
        def kill_client():
            # so it'll get GC'd
            cli = client.pop()
            cli._peer.sock.close()

        # hub does a self-rpc during which the client connection goes away
        result = hub.rpc('service', 0, 'method')

        self.assertEqual(result, 1)
Ejemplo n.º 5
0
    def test_downed_recipient_cancels_the_hub_sender_during_chunked_request(
            self):
        port = _free_port()
        hub = junction.Hub(("127.0.0.1", port), [])
        triggered = [False]

        @hub.accept_rpc('service', 0, 0, 'method')
        def handle(chunks):
            for item in chunks:
                pass
            return "all done"

        hub.start()

        port2 = _free_port()
        hub2 = junction.Hub(("127.0.0.1", port2), [("127.0.0.1", port)])
        hub2.start()
        hub2.wait_connected()

        def gen():
            try:
                while 1:
                    yield None
                    backend.pause_for(TIMEOUT)
            finally:
                triggered[0] = True

        rpc = hub2.send_rpc('service', 0, 'method', (gen(), ))

        hub = [hub]
        backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub, ))

        backend.pause_for(TIMEOUT * 5)

        assert triggered[0]
Ejemplo n.º 6
0
    def test_downed_hub_during_chunk_pub_to_client_terminates_correctly(self):
        port = _free_port()
        hub = junction.Hub(("127.0.0.1", port), [])
        l = []
        ev = backend.Event()

        @hub.accept_publish('service', 0, 0, 'method')
        def handle(x):
            for item in x:
                l.append(item)
            ev.set()

        hub.start()

        client = junction.Client(("127.0.0.1", port))
        client.connect()
        client.wait_connected()
        client = [client]

        def gen():
            yield 1
            yield 2
            self.kill_client(client)

        client[0].publish('service', 0, 'method', (gen(), ))
        ev.wait(TIMEOUT)

        self.assertEqual(l[:2], [1, 2])
        self.assertEqual(len(l), 3)
        self.assertIsInstance(l[-1], junction.errors.LostConnection)
Ejemplo n.º 7
0
    def test_unrelated_self_rpcs_are_unaffected(self):
        hub = junction.Hub(("127.0.0.1", _free_port()), [])

        @hub.accept_rpc('service', 0, 0, 'method')
        def handle():
            backend.pause_for(TIMEOUT)
            return 1

        hub.start()

        client = junction.Client(hub.addr)
        client.connect()
        client.wait_connected()
        client = [client]

        @backend.schedule
        def kill_client():
            # so it'll get GC'd
            cli = client.pop()
            cli._peer.sock.close()

        # hub does a self-rpc during which the client connection goes away
        result = hub.rpc('service', 0, 'method')

        self.assertEqual(result, 1)
Ejemplo n.º 8
0
    def test_unrelated_rpcs_are_unaffected(self):
        hub = junction.Hub(("127.0.0.1", _free_port()), [])

        @hub.accept_rpc('service', 0, 0, 'method')
        def handle():
            backend.pause_for(TIMEOUT)
            return 1

        hub.start()

        peer = junction.Hub(("127.0.0.1", _free_port()), [hub.addr])
        peer.start()
        peer.wait_connected()

        client = junction.Client(hub.addr)
        client.connect()
        client.wait_connected()
        client = [client]

        backend.schedule(self.kill_client, (client, ))

        # hub does a self-rpc during which the client connection goes away
        result = peer.rpc('service', 0, 'method')

        self.assertEqual(result, 1)
Ejemplo n.º 9
0
    def test_unrelated_client_chunked_publishes_are_unrelated(self):
        port = _free_port()
        hub = junction.Hub(("127.0.0.1", port), [])

        d = {}

        @hub.accept_publish('service', 0, 0, 'method')
        def handle(x, source):
            for item in x:
                d.setdefault(source, 0)
                d[source] += 1

        hub.start()

        c1 = junction.Client(("127.0.0.1", port))
        c1.connect()
        c1.wait_connected()
        c2 = junction.Client(("127.0.0.1", port))
        c2.connect()
        c2.wait_connected()

        def gen():
            backend.pause_for(TIMEOUT)
            yield None
            backend.pause_for(TIMEOUT)
            yield None
            backend.pause_for(TIMEOUT)
            yield None

        backend.schedule(c1.publish,
                         args=('service', 0, 'method'),
                         kwargs={
                             'args': (gen(), ),
                             'kwargs': {
                                 'source': 'a'
                             }
                         })
        backend.schedule(c2.publish,
                         args=('service', 0, 'method'),
                         kwargs={
                             'args': (gen(), ),
                             'kwargs': {
                                 'source': 'b'
                             }
                         })

        backend.pause_for(TIMEOUT)

        c2 = [c2]
        self.kill_client(c2)

        backend.pause_for(TIMEOUT)
        backend.pause_for(TIMEOUT)
        backend.pause_for(TIMEOUT)

        self.assertEquals(d, {'a': 3, 'b': 1})
Ejemplo n.º 10
0
    def test_unrelated_client_chunked_publishes_are_unrelated(self):
        port = _free_port()
        hub = junction.Hub(("127.0.0.1", port), [])

        d = {}

        @hub.accept_publish('service', 0, 0, 'method')
        def handle(x, source):
            for item in x:
                d.setdefault(source, 0)
                d[source] += 1

        hub.start()

        c1 = junction.Client(("127.0.0.1", port))
        c1.connect()
        c1.wait_connected()
        c2 = junction.Client(("127.0.0.1", port))
        c2.connect()
        c2.wait_connected()

        def gen():
            backend.pause_for(TIMEOUT)
            yield None
            backend.pause_for(TIMEOUT)
            yield None
            backend.pause_for(TIMEOUT)
            yield None

        backend.schedule(c1.publish, args=('service', 0, 'method'),
                kwargs={'args': (gen(),), 'kwargs': {'source': 'a'}})
        backend.schedule(c2.publish, args=('service', 0, 'method'),
                kwargs={'args': (gen(),), 'kwargs': {'source': 'b'}})

        backend.pause_for(TIMEOUT)

        c2 = [c2]
        self.kill_client(c2)

        backend.pause_for(TIMEOUT)
        backend.pause_for(TIMEOUT)
        backend.pause_for(TIMEOUT)

        self.assertEquals(d, {'a': 3, 'b': 1})