/** * 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(); }