// AVRO-625 [Test] public void CancelPendingRequestsOnTransceiverClose() { // Start up a second server so that closing the server doesn't // interfere with the other unit tests: var blockingSimpleImpl = new BlockingSimpleImpl(); var responder = new SpecificResponder <Simple>(blockingSimpleImpl); var server2 = new SocketServer("localhost", 0, responder); server2.Start(); try { int serverPort = server2.Port; var transceiver2 = new SocketTransceiver("localhost", serverPort); var addFuture = new CallFuture <int>(); try { var simpleClient2 = SpecificRequestor.CreateClient <SimpleCallback>(transceiver2); // The first call has to block for the handshake: Assert.AreEqual(3, simpleClient2.add(1, 2)); // Now acquire the semaphore so that the server will block: blockingSimpleImpl.acquireRunPermit(); simpleClient2.add(1, 2, addFuture); } finally { // When the transceiver is closed, the CallFuture should get // an IOException transceiver2.Close(); } bool ioeThrown = false; try { addFuture.WaitForResult(2000); } catch (Exception) { } //catch (ExecutionException e) { // ioeThrown = e.getCause() instanceof IOException; // Assert.assertTrue(e.getCause() instanceof IOException); //} catch (Exception e) { // e.printStackTrace(); // Assert.fail("Unexpected Exception: " + e.toString()); //} Assert.IsTrue(ioeThrown, "Expected IOException to be thrown"); } finally { blockingSimpleImpl.releaseRunPermit(); server2.Stop(); } }
public void ClientReconnectAfterServerRestart() { // Start up a second server so that closing the server doesn't // interfere with the other unit tests: SimpleImpl simpleImpl = new BlockingSimpleImpl(); var responder = new SpecificResponder <Simple>(simpleImpl); var server2 = new SocketServer("localhost", 0, responder); server2.Start(); try { int serverPort = server2.Port; // Initialize a client, and establish a connection to the server: Transceiver transceiver2 = new SocketTransceiver("localhost", serverPort); var simpleClient2 = SpecificRequestor.CreateClient <SimpleCallback>(transceiver2); Assert.AreEqual(3, simpleClient2.add(1, 2)); // Restart the server: server2.Stop(); try { simpleClient2.add(2, -1); Assert.Fail("Client should not be able to invoke RPCs because server is no longer running"); } catch (Exception) { // Expected since server is no longer running } Thread.Sleep(2000); server2 = new SocketServer("localhost", serverPort, new SpecificResponder <Simple>(new SimpleImpl())); server2.Start(); // Invoke an RPC using the same client, which should reestablish the // connection to the server: Assert.AreEqual(3, simpleClient2.add(1, 2)); } finally { server2.Stop(); } }
// AVRO-625 [Test] public void CancelPendingRequestsAfterChannelCloseByServerShutdown() { // The purpose of this test is to verify that a client doesn't stay // blocked when a server is unexpectedly killed (or when for some // other reason the channel is suddenly closed) while the server // was in the process of handling a request (thus after it received // the request, and before it returned the response). // Start up a second server so that closing the server doesn't // interfere with the other unit tests: var blockingSimpleImpl = new BlockingSimpleImpl(); var responder = new SpecificResponder <Simple>(blockingSimpleImpl); var server2 = new SocketServer("localhost", 0, responder); server2.Start(); SocketTransceiver transceiver2 = null; try { transceiver2 = new SocketTransceiver("localhost", server2.Port); var simpleClient2 = SpecificRequestor.CreateClient <SimpleCallback>(transceiver2); // Acquire the method-enter permit, which will be released by the // server method once we call it blockingSimpleImpl.acquireEnterPermit(); // Acquire the run permit, to avoid that the server method returns immediately blockingSimpleImpl.acquireRunPermit(); var t = new Thread(() => { try { simpleClient2.add(3, 4); Assert.Fail("Expected an exception"); } catch (Exception) { // expected } }); // Start client call t.Start(); // Wait until method is entered on the server side blockingSimpleImpl.acquireEnterPermit(); // The server side method is now blocked waiting on the run permit // (= is busy handling the request) // Stop the server server2.Stop(); // With the server gone, we expect the client to get some exception and exit // Wait for client thread to exit t.Join(10000); Assert.IsFalse(t.IsAlive, "Client request should not be blocked on server shutdown"); } finally { blockingSimpleImpl.releaseRunPermit(); server2.Stop(); if (transceiver2 != null) { transceiver2.Close(); } } }