/**
* In a situation where the upgrade/connection is successfull, and there is no activity for a
* while, the idle timeout triggers on the client side and automatically initiates a close
* handshake.
*/
@Test
public void testIdleDetectedByClient() throws Exception {
TrackingSocket wsocket = new TrackingSocket();
WebSocketClient client = factory.newWebSocketClient(wsocket);
URI wsUri = server.getWsUri();
Future<UpgradeResponse> future = client.connect(wsUri);
ServerConnection ssocket = server.accept();
ssocket.upgrade();
// Validate that connect occurred
future.get(500, TimeUnit.MILLISECONDS);
wsocket.waitForConnected(500, TimeUnit.MILLISECONDS);
// Wait for inactivity idle timeout.
long start = System.currentTimeMillis();
wsocket.waitForClose(10, TimeUnit.SECONDS);
long end = System.currentTimeMillis();
long dur = (end - start);
// Make sure idle timeout takes less than 5 total seconds
Assert.assertThat("Idle Timeout", dur, lessThanOrEqualTo(5000L));
// Client should see a close event, with status NO_CLOSE
wsocket.assertCloseCode(StatusCode.NORMAL);
}
/**
* Test for when encountering a "Transfer-Encoding: chunked" on a Upgrade Response header.
*
* <ul>
* <li><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=393075">Eclipse Jetty Bug
* #393075</a>
* <li><a href="https://issues.apache.org/bugzilla/show_bug.cgi?id=54067">Apache Tomcat Bug
* #54067</a>
* </ul>
*
* @throws Exception on test failure
*/
@Test
public void testTomcat7_0_32_WithTransferEncoding() throws Exception {
BlockheadServer server = new BlockheadServer();
WebSocketClient client = new WebSocketClient();
try {
final int bufferSize = 512;
server.start();
// Setup Client Factory
client.start();
// Create End User WebSocket Class
LatchedSocket websocket = new LatchedSocket();
// Open connection
URI wsURI = server.getWsUri();
client.connect(websocket, wsURI);
// Accept incoming connection
IBlockheadServerConnection socket = server.accept();
socket.setSoTimeout(2000); // timeout
// Issue upgrade
// Add the extra problematic header that triggers bug found in jetty-io
socket.addResponseHeader("Transfer-Encoding", "chunked");
socket.upgrade();
// Wait for proper upgrade
Assert.assertTrue(
"Timed out waiting for Client side WebSocket open event",
websocket.openLatch.await(1, TimeUnit.SECONDS));
// Have server write frame.
byte payload[] = new byte[bufferSize / 2];
Arrays.fill(payload, (byte) 'x');
ByteBuffer serverFrame = BufferUtil.allocate(bufferSize);
BufferUtil.flipToFill(serverFrame);
serverFrame.put((byte) (0x80 | 0x01)); // FIN + TEXT
serverFrame.put((byte) 0x7E); // No MASK and 2 bytes length
serverFrame.put((byte) (payload.length >> 8)); // first length byte
serverFrame.put((byte) (payload.length & 0xFF)); // second length byte
serverFrame.put(payload);
BufferUtil.flipToFlush(serverFrame, 0);
socket.write(serverFrame);
socket.flush();
Assert.assertTrue(websocket.dataLatch.await(1000, TimeUnit.SECONDS));
} finally {
client.stop();
server.stop();
}
}
@Test
@Slow
public void testServerSlowToRead() throws Exception {
TrackingSocket tsocket = new TrackingSocket();
client.setMasker(new ZeroMasker());
client.getPolicy().setIdleTimeout(60000);
URI wsUri = server.getWsUri();
Future<Session> future = client.connect(tsocket, wsUri);
ServerConnection sconnection = server.accept();
sconnection.setSoTimeout(60000);
sconnection.upgrade();
// Confirm connected
future.get(500, TimeUnit.MILLISECONDS);
tsocket.waitForConnected(500, TimeUnit.MILLISECONDS);
int messageCount = 10; // TODO: increase to 1000
// Setup slow server read thread
ServerReadThread reader = new ServerReadThread(sconnection);
reader.setExpectedMessageCount(messageCount);
reader.setSlowness(100); // slow it down
reader.start();
// Have client write as quickly as it can.
ClientWriteThread writer = new ClientWriteThread(tsocket.getConnection());
writer.setMessageCount(messageCount);
writer.setMessage("Hello");
writer.setSlowness(-1); // disable slowness
writer.start();
writer.join();
// Verify receive
reader.waitForExpectedMessageCount(10, TimeUnit.SECONDS);
Assert.assertThat("Frame Receive Count", reader.getFrameCount(), is(messageCount));
// Close
tsocket.getConnection().close(StatusCode.NORMAL, "Done");
Assert.assertTrue("Client Socket Closed", tsocket.closeLatch.await(10, TimeUnit.SECONDS));
tsocket.assertCloseCode(StatusCode.NORMAL);
reader.cancel(); // stop reading
}
public void run() {
try {
WebSocketClient client =
new WebSocketClient(cli, WebSocketServer.this.listenerClass.newInstance());
client.setExecutor(socketServer.executor);
client.setScheduler(socketServer.scheduler);
client.service();
} catch (Exception e) {
logger.error(e.getMessage(), e);
} finally {
try {
cli.close();
} catch (IOException io) {
logger.error(io.getMessage(), io);
}
}
}
public void run()
{
Thread.currentThread().setName("WebsocketWriteThread");
try
{
for (; !Thread.interrupted(); WebSocketClient.access$200(WebSocketClient.this).flush())
{
ByteBuffer bytebuffer = (ByteBuffer)WebSocketClient.access$100(WebSocketClient.this).outQueue.take();
WebSocketClient.access$200(WebSocketClient.this).write(bytebuffer.array(), 0, bytebuffer.limit());
}
}
catch (IOException ioexception)
{
WebSocketClient.access$100(WebSocketClient.this).eot();
}
catch (InterruptedException interruptedexception)
{
return;
}
}
@Test
@Slow
public void testServerSlowToSend() throws Exception {
// final Exchanger<String> exchanger = new Exchanger<String>();
TrackingSocket tsocket = new TrackingSocket();
// tsocket.messageExchanger = exchanger;
client.setMasker(new ZeroMasker());
client.getPolicy().setIdleTimeout(60000);
URI wsUri = server.getWsUri();
Future<Session> future = client.connect(tsocket, wsUri);
ServerConnection sconnection = server.accept();
sconnection.setSoTimeout(60000);
sconnection.upgrade();
// Confirm connected
future.get(500, TimeUnit.MILLISECONDS);
tsocket.waitForConnected(500, TimeUnit.MILLISECONDS);
// Have server write slowly.
int messageCount = 1000;
ServerWriteThread writer = new ServerWriteThread(sconnection);
writer.setMessageCount(messageCount);
writer.setMessage("Hello");
// writer.setExchanger(exchanger);
writer.setSlowness(10);
writer.start();
writer.join();
// Verify receive
Assert.assertThat("Message Receive Count", tsocket.messageQueue.size(), is(messageCount));
// Close
sconnection.close(StatusCode.NORMAL);
Assert.assertTrue("Client Socket Closed", tsocket.closeLatch.await(10, TimeUnit.SECONDS));
tsocket.assertCloseCode(StatusCode.NORMAL);
}
@After
public void stopClient() throws Exception {
client.stop();
}
@Before
public void startClient() throws Exception {
client = new WebSocketClient();
client.getPolicy().setIdleTimeout(60000);
client.start();
}
