Examples with Stream org.eclipse.jetty.http2.api.Stream used on opensource projects

Example 86 with Stream

use of org.eclipse.jetty.http2.api.Stream in project jetty.project by eclipse.

the class TrailersTest method testServletRequestTrailers.

@Test
public void testServletRequestTrailers() throws Exception {
    CountDownLatch trailerLatch = new CountDownLatch(1);
    start(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            Request jettyRequest = (Request) request;
            // No trailers yet.
            Assert.assertNull(jettyRequest.getTrailers());
            trailerLatch.countDown();
            // Read the content.
            ServletInputStream input = jettyRequest.getInputStream();
            while (true) {
                int read = input.read();
                if (read < 0)
                    break;
            }
            // Now we have the trailers.
            HttpFields trailers = jettyRequest.getTrailers();
            Assert.assertNotNull(trailers);
            Assert.assertNotNull(trailers.get("X-Trailer"));
        }
    });
    Session session = newClient(new Session.Listener.Adapter());
    HttpFields requestFields = new HttpFields();
    requestFields.put("X-Request", "true");
    MetaData.Request request = newRequest("GET", requestFields);
    HeadersFrame requestFrame = new HeadersFrame(request, null, false);
    FuturePromise<Stream> streamPromise = new FuturePromise<>();
    CountDownLatch latch = new CountDownLatch(1);
    session.newStream(requestFrame, streamPromise, new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            MetaData.Response response = (MetaData.Response) frame.getMetaData();
            Assert.assertEquals(HttpStatus.OK_200, response.getStatus());
            if (frame.isEndStream())
                latch.countDown();
        }
    });
    Stream stream = streamPromise.get(5, TimeUnit.SECONDS);
    // Send some data.
    Callback.Completable callback = new Callback.Completable();
    stream.data(new DataFrame(stream.getId(), ByteBuffer.allocate(16), false), callback);
    Assert.assertTrue(trailerLatch.await(5, TimeUnit.SECONDS));
    // Send the trailers.
    callback.thenRun(() -> {
        HttpFields trailerFields = new HttpFields();
        trailerFields.put("X-Trailer", "true");
        MetaData trailers = new MetaData(HttpVersion.HTTP_2, trailerFields);
        HeadersFrame trailerFrame = new HeadersFrame(stream.getId(), trailers, null, true);
        stream.headers(trailerFrame, Callback.NOOP);
    });
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
}

Example 87 with Stream

use of org.eclipse.jetty.http2.api.Stream in project jetty.project by eclipse.

the class RawHTTP2ProxyTest method testRawHTTP2Proxy.

@Test
public void testRawHTTP2Proxy() throws Exception {
    byte[] data1 = new byte[1024];
    new Random().nextBytes(data1);
    ByteBuffer buffer1 = ByteBuffer.wrap(data1);
    Server server1 = startServer("server1", new ServerSessionListener.Adapter() {

        @Override
        public Stream.Listener onNewStream(Stream stream, HeadersFrame frame) {
            if (LOGGER.isDebugEnabled())
                LOGGER.debug("SERVER1 received {}", frame);
            return new Stream.Listener.Adapter() {

                @Override
                public void onHeaders(Stream stream, HeadersFrame frame) {
                    if (LOGGER.isDebugEnabled())
                        LOGGER.debug("SERVER1 received {}", frame);
                    if (frame.isEndStream()) {
                        MetaData.Response response = new MetaData.Response(HttpVersion.HTTP_2, HttpStatus.OK_200, new HttpFields());
                        HeadersFrame reply = new HeadersFrame(stream.getId(), response, null, false);
                        if (LOGGER.isDebugEnabled())
                            LOGGER.debug("SERVER1 sending {}", reply);
                        stream.headers(reply, new Callback() {

                            @Override
                            public void succeeded() {
                                DataFrame data = new DataFrame(stream.getId(), buffer1.slice(), true);
                                if (LOGGER.isDebugEnabled())
                                    LOGGER.debug("SERVER1 sending {}", data);
                                stream.data(data, NOOP);
                            }
                        });
                    }
                }
            };
        }
    });
    ServerConnector connector1 = (ServerConnector) server1.getAttribute("connector");
    Server server2 = startServer("server2", new ServerSessionListener.Adapter() {

        @Override
        public Stream.Listener onNewStream(Stream stream, HeadersFrame frame) {
            if (LOGGER.isDebugEnabled())
                LOGGER.debug("SERVER2 received {}", frame);
            return new Stream.Listener.Adapter() {

                @Override
                public void onData(Stream stream, DataFrame frame, Callback callback) {
                    if (LOGGER.isDebugEnabled())
                        LOGGER.debug("SERVER2 received {}", frame);
                    callback.succeeded();
                    MetaData.Response response = new MetaData.Response(HttpVersion.HTTP_2, HttpStatus.OK_200, new HttpFields());
                    Callback.Completable completable1 = new Callback.Completable();
                    HeadersFrame reply = new HeadersFrame(stream.getId(), response, null, false);
                    if (LOGGER.isDebugEnabled())
                        LOGGER.debug("SERVER2 sending {}", reply);
                    stream.headers(reply, completable1);
                    completable1.thenCompose(ignored -> {
                        Callback.Completable completable2 = new Callback.Completable();
                        DataFrame data = new DataFrame(stream.getId(), buffer1.slice(), false);
                        if (LOGGER.isDebugEnabled())
                            LOGGER.debug("SERVER2 sending {}", data);
                        stream.data(data, completable2);
                        return completable2;
                    }).thenRun(() -> {
                        MetaData trailer = new MetaData(HttpVersion.HTTP_2, new HttpFields());
                        HeadersFrame end = new HeadersFrame(stream.getId(), trailer, null, true);
                        if (LOGGER.isDebugEnabled())
                            LOGGER.debug("SERVER2 sending {}", end);
                        stream.headers(end, Callback.NOOP);
                    });
                }
            };
        }
    });
    ServerConnector connector2 = (ServerConnector) server2.getAttribute("connector");
    HTTP2Client proxyClient = startClient("proxyClient");
    Server proxyServer = startServer("proxyServer", new ClientToProxySessionListener(proxyClient));
    ServerConnector proxyConnector = (ServerConnector) proxyServer.getAttribute("connector");
    InetSocketAddress proxyAddress = new InetSocketAddress("localhost", proxyConnector.getLocalPort());
    HTTP2Client client = startClient("client");
    FuturePromise<Session> clientPromise = new FuturePromise<>();
    client.connect(proxyAddress, new Session.Listener.Adapter(), clientPromise);
    Session clientSession = clientPromise.get(5, TimeUnit.SECONDS);
    // Send a request with trailers for server1.
    HttpFields fields1 = new HttpFields();
    fields1.put("X-Target", String.valueOf(connector1.getLocalPort()));
    MetaData.Request request1 = new MetaData.Request("GET", new HttpURI("http://localhost/server1"), HttpVersion.HTTP_2, fields1);
    FuturePromise<Stream> streamPromise1 = new FuturePromise<>();
    CountDownLatch latch1 = new CountDownLatch(1);
    clientSession.newStream(new HeadersFrame(request1, null, false), streamPromise1, new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            if (LOGGER.isDebugEnabled())
                LOGGER.debug("CLIENT received {}", frame);
        }

        @Override
        public void onData(Stream stream, DataFrame frame, Callback callback) {
            if (LOGGER.isDebugEnabled())
                LOGGER.debug("CLIENT received {}", frame);
            Assert.assertEquals(buffer1.slice(), frame.getData());
            callback.succeeded();
            latch1.countDown();
        }
    });
    Stream stream1 = streamPromise1.get(5, TimeUnit.SECONDS);
    stream1.headers(new HeadersFrame(stream1.getId(), new MetaData(HttpVersion.HTTP_2, new HttpFields()), null, true), Callback.NOOP);
    // Send a request for server2.
    HttpFields fields2 = new HttpFields();
    fields2.put("X-Target", String.valueOf(connector2.getLocalPort()));
    MetaData.Request request2 = new MetaData.Request("GET", new HttpURI("http://localhost/server1"), HttpVersion.HTTP_2, fields2);
    FuturePromise<Stream> streamPromise2 = new FuturePromise<>();
    CountDownLatch latch2 = new CountDownLatch(1);
    clientSession.newStream(new HeadersFrame(request2, null, false), streamPromise2, new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            if (LOGGER.isDebugEnabled())
                LOGGER.debug("CLIENT received {}", frame);
            if (frame.isEndStream())
                latch2.countDown();
        }

        @Override
        public void onData(Stream stream, DataFrame frame, Callback callback) {
            if (LOGGER.isDebugEnabled())
                LOGGER.debug("CLIENT received {}", frame);
            callback.succeeded();
        }
    });
    Stream stream2 = streamPromise2.get(5, TimeUnit.SECONDS);
    stream2.data(new DataFrame(stream2.getId(), buffer1.slice(), true), Callback.NOOP);
    Assert.assertTrue(latch1.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(latch2.await(5, TimeUnit.SECONDS));
}

Example 88 with Stream

use of org.eclipse.jetty.http2.api.Stream in project jetty.project by eclipse.

the class SessionFailureTest method testWriteFailure.

@Test
public void testWriteFailure() throws Exception {
    final CountDownLatch writeLatch = new CountDownLatch(1);
    final CountDownLatch serverFailureLatch = new CountDownLatch(1);
    start(new ServerSessionListener.Adapter() {

        @Override
        public Stream.Listener onNewStream(Stream stream, HeadersFrame frame) {
            // Forcibly close the connection.
            ((HTTP2Session) stream.getSession()).getEndPoint().close();
            // Now try to write something: it should fail.
            stream.headers(frame, new Callback() {

                @Override
                public void failed(Throwable x) {
                    writeLatch.countDown();
                }
            });
            return null;
        }

        @Override
        public void onFailure(Session session, Throwable failure) {
            serverFailureLatch.countDown();
        }
    });
    final CountDownLatch clientFailureLatch = new CountDownLatch(1);
    Session session = newClient(new Session.Listener.Adapter() {

        @Override
        public void onFailure(Session session, Throwable failure) {
            clientFailureLatch.countDown();
        }
    });
    HeadersFrame frame = new HeadersFrame(newRequest("GET", new HttpFields()), null, true);
    Promise<Stream> promise = new Promise.Adapter<>();
    session.newStream(frame, promise, null);
    Assert.assertTrue(writeLatch.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(serverFailureLatch.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(clientFailureLatch.await(5, TimeUnit.SECONDS));
    long start = System.nanoTime();
    long now = System.nanoTime();
    while (((HTTP2Session) session).getEndPoint().isOpen()) {
        if (TimeUnit.NANOSECONDS.toSeconds(now - start) > 5)
            Assert.fail();
        Thread.sleep(10);
        now = System.nanoTime();
    }
}

Example 89 with Stream

use of org.eclipse.jetty.http2.api.Stream in project jetty.project by eclipse.

the class SmallThreadPoolLoadTest method test.

private boolean test(Session session, CountDownLatch latch) throws Exception {
    ThreadLocalRandom random = ThreadLocalRandom.current();
    // Choose a random method
    boolean download = random.nextBoolean();
    HttpMethod method = download ? HttpMethod.GET : HttpMethod.POST;
    int maxContentLength = 128 * 1024;
    int contentLength = random.nextInt(maxContentLength) + 1;
    long requestId = requestIds.incrementAndGet();
    MetaData.Request request = newRequest(method.asString(), "/" + requestId, new HttpFields());
    if (download)
        request.getFields().put("X-Download", String.valueOf(contentLength));
    HeadersFrame requestFrame = new HeadersFrame(request, null, download);
    FuturePromise<Stream> promise = new FuturePromise<>();
    CountDownLatch requestLatch = new CountDownLatch(1);
    AtomicBoolean reset = new AtomicBoolean();
    session.newStream(requestFrame, promise, new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            if (frame.isEndStream())
                requestLatch.countDown();
        }

        @Override
        public void onData(Stream stream, DataFrame frame, Callback callback) {
            callback.succeeded();
            if (frame.isEndStream())
                requestLatch.countDown();
        }

        @Override
        public void onReset(Stream stream, ResetFrame frame) {
            reset.set(true);
            requestLatch.countDown();
        }
    });
    if (!download) {
        Stream stream = promise.get(5, TimeUnit.SECONDS);
        stream.data(new DataFrame(stream.getId(), ByteBuffer.allocate(contentLength), true), Callback.NOOP);
    }
    boolean success = requestLatch.await(5, TimeUnit.SECONDS);
    if (success)
        latch.countDown();
    else
        logger.warn("Request {} took too long{}Server:{}{}{}Client:{}{}", requestId, System.lineSeparator(), System.lineSeparator(), server.dump(), System.lineSeparator(), System.lineSeparator(), client.dump());
    return !reset.get();
}

Example 90 with Stream

use of org.eclipse.jetty.http2.api.Stream in project jetty.project by eclipse.

the class StreamCloseTest method testRequestClosedResponseClosedClosesStream.

@Test
public void testRequestClosedResponseClosedClosesStream() throws Exception {
    final CountDownLatch latch = new CountDownLatch(2);
    start(new ServerSessionListener.Adapter() {

        @Override
        public Stream.Listener onNewStream(final Stream stream, HeadersFrame frame) {
            MetaData.Response metaData = new MetaData.Response(HttpVersion.HTTP_2, 200, new HttpFields());
            HeadersFrame response = new HeadersFrame(stream.getId(), metaData, null, true);
            stream.headers(response, new Callback() {

                @Override
                public void succeeded() {
                    Assert.assertTrue(stream.isClosed());
                    Assert.assertEquals(0, stream.getSession().getStreams().size());
                    latch.countDown();
                }
            });
            return null;
        }
    });
    Session session = newClient(new Session.Listener.Adapter());
    HeadersFrame frame = new HeadersFrame(newRequest("GET", new HttpFields()), null, true);
    FuturePromise<Stream> promise = new FuturePromise<>();
    session.newStream(frame, promise, new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            // The stream promise may not be notified yet here.
            latch.countDown();
        }
    });
    Stream stream = promise.get(5, TimeUnit.SECONDS);
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(stream.isClosed());
}