Examples with Callback org.eclipse.jetty.util.Callback used on opensource projects

Example 61 with Callback

use of org.eclipse.jetty.util.Callback in project jetty.project by eclipse.

the class IdleTimeoutTest method testStreamIdleTimeoutIsNotEnforcedWhenReceiving.

@Test
public void testStreamIdleTimeoutIsNotEnforcedWhenReceiving() throws Exception {
    final CountDownLatch timeoutLatch = new CountDownLatch(1);
    start(new ServerSessionListener.Adapter() {

        @Override
        public Stream.Listener onNewStream(Stream stream, HeadersFrame frame) {
            stream.setIdleTimeout(idleTimeout);
            return new Stream.Listener.Adapter() {

                @Override
                public boolean onIdleTimeout(Stream stream, Throwable x) {
                    timeoutLatch.countDown();
                    return true;
                }
            };
        }
    });
    Session session = newClient(new Session.Listener.Adapter());
    MetaData.Request metaData = newRequest("GET", new HttpFields());
    HeadersFrame requestFrame = new HeadersFrame(metaData, null, false);
    FuturePromise<Stream> promise = new FuturePromise<>();
    session.newStream(requestFrame, promise, new Stream.Listener.Adapter());
    final Stream stream = promise.get(5, TimeUnit.SECONDS);
    sleep(idleTimeout / 2);
    final CountDownLatch dataLatch = new CountDownLatch(1);
    stream.data(new DataFrame(stream.getId(), ByteBuffer.allocate(1), false), new Callback() {

        private int sends;

        @Override
        public void succeeded() {
            sleep(idleTimeout / 2);
            final boolean last = ++sends == 2;
            stream.data(new DataFrame(stream.getId(), ByteBuffer.allocate(1), last), !last ? this : new Callback() {

                @Override
                public InvocationType getInvocationType() {
                    return InvocationType.NON_BLOCKING;
                }

                @Override
                public void succeeded() {
                    // Idle timeout should not fire while receiving.
                    Assert.assertEquals(1, timeoutLatch.getCount());
                    dataLatch.countDown();
                }
            });
        }
    });
    Assert.assertTrue(dataLatch.await(5 * idleTimeout, TimeUnit.MILLISECONDS));
    // The server did not send a response, so it will eventually timeout.
    Assert.assertTrue(timeoutLatch.await(5 * idleTimeout, TimeUnit.SECONDS));
}

Example 62 with Callback

use of org.eclipse.jetty.util.Callback in project jetty.project by eclipse.

the class HTTP2Session method doStop.

@Override
protected void doStop() throws Exception {
    super.doStop();
    close(ErrorCode.NO_ERROR.code, "stop", new Callback() {

        @Override
        public void succeeded() {
            disconnect();
        }

        @Override
        public void failed(Throwable x) {
            disconnect();
        }

        @Override
        public InvocationType getInvocationType() {
            return InvocationType.NON_BLOCKING;
        }
    });
}

Example 63 with Callback

use of org.eclipse.jetty.util.Callback in project jetty.project by eclipse.

the class ServerTimeoutsTest method testNoBlockingTimeoutBlockingWriteIdleTimeoutFires.

@Test
public void testNoBlockingTimeoutBlockingWriteIdleTimeoutFires() throws Exception {
    httpConfig.setBlockingTimeout(-1);
    CountDownLatch handlerLatch = new CountDownLatch(1);
    start(new BlockingWriteHandler(handlerLatch));
    long idleTimeout = 2500;
    setServerIdleTimeout(idleTimeout);
    try (StacklessLogging stackless = new StacklessLogging(HttpChannel.class)) {
        BlockingQueue<Callback> callbacks = new LinkedBlockingQueue<>();
        CountDownLatch resultLatch = new CountDownLatch(1);
        client.newRequest(newURI()).onResponseContentAsync((response, content, callback) -> {
            // Do not succeed the callback so the server will block writing.
            callbacks.offer(callback);
        }).send(result -> {
            if (result.isFailed())
                resultLatch.countDown();
        });
        // Blocking write should timeout.
        Assert.assertTrue(handlerLatch.await(2 * idleTimeout, TimeUnit.MILLISECONDS));
        // After the server stopped sending, consume on the client to read the early EOF.
        while (true) {
            Callback callback = callbacks.poll(1, TimeUnit.SECONDS);
            if (callback == null)
                break;
            callback.succeeded();
        }
        Assert.assertTrue(resultLatch.await(5, TimeUnit.SECONDS));
    }
}

Example 64 with Callback

use of org.eclipse.jetty.util.Callback in project jetty.project by eclipse.

the class HttpClientChunkedContentTest method test_Server_ContentTerminal_Client_ContentDelay.

@Test
public void test_Server_ContentTerminal_Client_ContentDelay() throws Exception {
    startClient();
    try (ServerSocket server = new ServerSocket()) {
        server.bind(new InetSocketAddress("localhost", 0));
        final AtomicReference<Callback> callbackRef = new AtomicReference<>();
        final CountDownLatch firstContentLatch = new CountDownLatch(1);
        final AtomicReference<Result> resultRef = new AtomicReference<>();
        final CountDownLatch completeLatch = new CountDownLatch(1);
        client.newRequest("localhost", server.getLocalPort()).onResponseContentAsync(new Response.AsyncContentListener() {

            @Override
            public void onContent(Response response, ByteBuffer content, Callback callback) {
                if (callbackRef.compareAndSet(null, callback))
                    firstContentLatch.countDown();
                else
                    callback.succeeded();
            }
        }).timeout(5, TimeUnit.SECONDS).send(new Response.CompleteListener() {

            @Override
            public void onComplete(Result result) {
                resultRef.set(result);
                completeLatch.countDown();
            }
        });
        try (Socket socket = server.accept()) {
            consumeRequestHeaders(socket);
            OutputStream output = socket.getOutputStream();
            String response = "" + "HTTP/1.1 200 OK\r\n" + "Transfer-Encoding: chunked\r\n" + "\r\n" + "8\r\n" + "01234567\r\n" + "0\r\n" + "\r\n";
            output.write(response.getBytes(StandardCharsets.UTF_8));
            output.flush();
            // Simulate a delay in consuming the content.
            assertTrue(firstContentLatch.await(5, TimeUnit.SECONDS));
            Thread.sleep(1000);
            callbackRef.get().succeeded();
            // Wait for the client to read 0 and become idle.
            Thread.sleep(1000);
            assertTrue(completeLatch.await(5, TimeUnit.SECONDS));
            Result result = resultRef.get();
            assertTrue(result.isSucceeded());
            Assert.assertEquals(200, result.getResponse().getStatus());
            // Issue another request to be sure the connection is sane.
            Request request = client.newRequest("localhost", server.getLocalPort()).timeout(5, TimeUnit.SECONDS);
            FutureResponseListener listener = new FutureResponseListener(request);
            request.send(listener);
            consumeRequestHeaders(socket);
            output.write(response.getBytes(StandardCharsets.UTF_8));
            output.flush();
            Assert.assertEquals(200, listener.get(5, TimeUnit.SECONDS).getStatus());
        }
    }
}

Example 65 with Callback

use of org.eclipse.jetty.util.Callback in project jetty.project by eclipse.

the class HttpClientFailureTest method testFailureAfterRequestCommit.

@Test
public void testFailureAfterRequestCommit() throws Exception {
    startServer(new EmptyServerHandler());
    final AtomicReference<HttpConnectionOverHTTP> connectionRef = new AtomicReference<>();
    client = new HttpClient(new HttpClientTransportOverHTTP() {

        @Override
        protected HttpConnectionOverHTTP newHttpConnection(EndPoint endPoint, HttpDestination destination, Promise<Connection> promise) {
            HttpConnectionOverHTTP connection = super.newHttpConnection(endPoint, destination, promise);
            connectionRef.set(connection);
            return connection;
        }
    }, null);
    client.start();
    final CountDownLatch commitLatch = new CountDownLatch(1);
    final CountDownLatch completeLatch = new CountDownLatch(1);
    DeferredContentProvider content = new DeferredContentProvider();
    client.newRequest("localhost", connector.getLocalPort()).onRequestCommit(request -> {
        connectionRef.get().getEndPoint().close();
        commitLatch.countDown();
    }).content(content).idleTimeout(2, TimeUnit.SECONDS).send(result -> {
        if (result.isFailed())
            completeLatch.countDown();
    });
    Assert.assertTrue(commitLatch.await(5, TimeUnit.SECONDS));
    final CountDownLatch contentLatch = new CountDownLatch(1);
    content.offer(ByteBuffer.allocate(1024), new Callback() {

        @Override
        public void failed(Throwable x) {
            contentLatch.countDown();
        }
    });
    Assert.assertTrue(commitLatch.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(contentLatch.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(completeLatch.await(5, TimeUnit.SECONDS));
    DuplexConnectionPool connectionPool = (DuplexConnectionPool) connectionRef.get().getHttpDestination().getConnectionPool();
    Assert.assertEquals(0, connectionPool.getConnectionCount());
    Assert.assertEquals(0, connectionPool.getActiveConnections().size());
    Assert.assertEquals(0, connectionPool.getIdleConnections().size());
}