Examples with MetaData org.eclipse.jetty.http.MetaData used on opensource projects

Example 31 with MetaData

use of org.eclipse.jetty.http.MetaData in project jetty.project by eclipse.

the class PushCacheFilterTest method testPushWithQueryParameters.

@Test
public void testPushWithQueryParameters() throws Exception {
    String name = "foo";
    String value = "bar";
    final String primaryResource = "/primary.html?" + name + "=" + value;
    final String secondaryResource = "/secondary.html?" + name + "=" + value;
    start(new HttpServlet() {

        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            String requestURI = request.getRequestURI();
            if (requestURI.endsWith(primaryResource)) {
                response.setStatus(HttpStatus.OK_200);
            } else if (requestURI.endsWith(secondaryResource)) {
                String param = request.getParameter(name);
                if (param == null)
                    response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR_500);
                else
                    response.setStatus(HttpStatus.OK_200);
            }
        }
    });
    final Session session = newClient(new Session.Listener.Adapter());
    // Request for the primary and secondary resource to build the cache.
    final String primaryURI = newURI(primaryResource);
    HttpFields primaryFields = new HttpFields();
    MetaData.Request primaryRequest = newRequest("GET", primaryResource, primaryFields);
    final CountDownLatch warmupLatch = new CountDownLatch(1);
    session.newStream(new HeadersFrame(primaryRequest, null, true), new Promise.Adapter<>(), new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            if (frame.isEndStream()) {
                // Request for the secondary resource.
                HttpFields secondaryFields = new HttpFields();
                secondaryFields.put(HttpHeader.REFERER, primaryURI);
                MetaData.Request secondaryRequest = newRequest("GET", secondaryResource, secondaryFields);
                session.newStream(new HeadersFrame(secondaryRequest, null, true), new Promise.Adapter<>(), new Stream.Listener.Adapter() {

                    @Override
                    public void onHeaders(Stream stream, HeadersFrame frame) {
                        if (frame.isEndStream())
                            warmupLatch.countDown();
                    }
                });
            }
        }
    });
    Assert.assertTrue(warmupLatch.await(5, TimeUnit.SECONDS));
    Thread.sleep(1000);
    // Request again the primary resource, we should get the secondary resource pushed.
    primaryRequest = newRequest("GET", primaryResource, primaryFields);
    final CountDownLatch primaryResponseLatch = new CountDownLatch(1);
    final CountDownLatch pushLatch = new CountDownLatch(1);
    session.newStream(new HeadersFrame(primaryRequest, null, true), new Promise.Adapter<>(), new Stream.Listener.Adapter() {

        @Override
        public Stream.Listener onPush(Stream stream, PushPromiseFrame frame) {
            MetaData metaData = frame.getMetaData();
            Assert.assertTrue(metaData instanceof MetaData.Request);
            MetaData.Request pushedRequest = (MetaData.Request) metaData;
            Assert.assertEquals(contextPath + servletPath + secondaryResource, pushedRequest.getURI().getPathQuery());
            return new Adapter() {

                @Override
                public void onHeaders(Stream stream, HeadersFrame frame) {
                    if (frame.isEndStream()) {
                        MetaData.Response response = (MetaData.Response) frame.getMetaData();
                        if (response.getStatus() == HttpStatus.OK_200)
                            pushLatch.countDown();
                    }
                }
            };
        }

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            if (frame.isEndStream())
                primaryResponseLatch.countDown();
        }
    });
    Assert.assertTrue(pushLatch.await(5, TimeUnit.SECONDS));
    Assert.assertTrue(primaryResponseLatch.await(5, TimeUnit.SECONDS));
}

Example 32 with MetaData

use of org.eclipse.jetty.http.MetaData in project jetty.project by eclipse.

the class AsyncServletTest method testStartAsyncThenServerIdleTimeout.

private void testStartAsyncThenServerIdleTimeout(long sessionTimeout, long streamTimeout) throws Exception {
    prepareServer(new HTTP2ServerConnectionFactory(new HttpConfiguration()) {

        @Override
        protected ServerSessionListener newSessionListener(Connector connector, EndPoint endPoint) {
            return new HTTPServerSessionListener(connector, endPoint) {

                @Override
                public Stream.Listener onNewStream(Stream stream, HeadersFrame frame) {
                    stream.setIdleTimeout(streamTimeout);
                    return super.onNewStream(stream, frame);
                }
            };
        }
    });
    connector.setIdleTimeout(sessionTimeout);
    ServletContextHandler context = new ServletContextHandler(server, "/");
    long timeout = Math.min(sessionTimeout, streamTimeout);
    CountDownLatch errorLatch = new CountDownLatch(1);
    context.addServlet(new ServletHolder(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            AsyncContext asyncContext = (AsyncContext) request.getAttribute(AsyncContext.class.getName());
            if (asyncContext == null) {
                AsyncContext context = request.startAsync();
                context.setTimeout(2 * timeout);
                request.setAttribute(AsyncContext.class.getName(), context);
                context.addListener(new AsyncListener() {

                    @Override
                    public void onComplete(AsyncEvent event) throws IOException {
                    }

                    @Override
                    public void onTimeout(AsyncEvent event) throws IOException {
                        event.getAsyncContext().complete();
                    }

                    @Override
                    public void onError(AsyncEvent event) throws IOException {
                        errorLatch.countDown();
                    }

                    @Override
                    public void onStartAsync(AsyncEvent event) throws IOException {
                    }
                });
            } else {
                throw new ServletException();
            }
        }
    }), servletPath + "/*");
    server.start();
    prepareClient();
    client.start();
    Session session = newClient(new Session.Listener.Adapter());
    HttpFields fields = new HttpFields();
    MetaData.Request metaData = newRequest("GET", fields);
    HeadersFrame frame = new HeadersFrame(metaData, null, true);
    CountDownLatch clientLatch = new CountDownLatch(1);
    session.newStream(frame, new Promise.Adapter<>(), new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            MetaData.Response response = (MetaData.Response) frame.getMetaData();
            if (response.getStatus() == HttpStatus.OK_200 && frame.isEndStream())
                clientLatch.countDown();
        }
    });
    // When the server idle times out, but the request has been dispatched
    // then the server must ignore the idle timeout as per Servlet semantic.
    Assert.assertFalse(errorLatch.await(2 * timeout, TimeUnit.MILLISECONDS));
    Assert.assertTrue(clientLatch.await(2 * timeout, TimeUnit.MILLISECONDS));
}

Example 33 with MetaData

use of org.eclipse.jetty.http.MetaData in project jetty.project by eclipse.

the class AsyncServletTest method testStartAsyncThenClientSessionIdleTimeout.

@Test
public void testStartAsyncThenClientSessionIdleTimeout() throws Exception {
    CountDownLatch serverLatch = new CountDownLatch(1);
    start(new AsyncOnErrorServlet(serverLatch));
    long idleTimeout = 1000;
    client.setIdleTimeout(idleTimeout);
    Session session = newClient(new Session.Listener.Adapter());
    HttpFields fields = new HttpFields();
    MetaData.Request metaData = newRequest("GET", fields);
    HeadersFrame frame = new HeadersFrame(metaData, null, true);
    FuturePromise<Stream> promise = new FuturePromise<>();
    CountDownLatch clientLatch = new CountDownLatch(1);
    session.newStream(frame, promise, new Stream.Listener.Adapter() {

        @Override
        public void onHeaders(Stream stream, HeadersFrame frame) {
            MetaData.Response response = (MetaData.Response) frame.getMetaData();
            if (response.getStatus() == HttpStatus.INTERNAL_SERVER_ERROR_500 && frame.isEndStream())
                clientLatch.countDown();
        }
    });
    Stream stream = promise.get(5, TimeUnit.SECONDS);
    stream.setIdleTimeout(10 * idleTimeout);
    // When the client closes, the server receives the
    // corresponding frame and acts by notifying the failure,
    // which sends back to the client the error response.
    Assert.assertTrue(serverLatch.await(2 * idleTimeout, TimeUnit.MILLISECONDS));
    Assert.assertTrue(clientLatch.await(2 * idleTimeout, TimeUnit.MILLISECONDS));
}

Example 34 with MetaData

use of org.eclipse.jetty.http.MetaData in project jetty.project by eclipse.

the class AsyncServletTest method testStartAsyncThenDispatch.

@Test
public void testStartAsyncThenDispatch() throws Exception {
    byte[] content = new byte[1024];
    new Random().nextBytes(content);
    start(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            AsyncContext asyncContext = (AsyncContext) request.getAttribute(AsyncContext.class.getName());
            if (asyncContext == null) {
                AsyncContext context = request.startAsync();
                context.setTimeout(0);
                request.setAttribute(AsyncContext.class.getName(), context);
                context.start(() -> {
                    sleep(1000);
                    context.dispatch();
                });
            } else {
                response.getOutputStream().write(content);
            }
        }
    });
    Session session = newClient(new Session.Listener.Adapter());
    HttpFields fields = new HttpFields();
    MetaData.Request metaData = newRequest("GET", fields);
    HeadersFrame frame = new HeadersFrame(metaData, null, true);
    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
    CountDownLatch latch = new CountDownLatch(1);
    session.newStream(frame, new Promise.Adapter<>(), new Stream.Listener.Adapter() {

        @Override
        public void onData(Stream stream, DataFrame frame, Callback callback) {
            try {
                buffer.write(BufferUtil.toArray(frame.getData()));
                callback.succeeded();
                if (frame.isEndStream())
                    latch.countDown();
            } catch (IOException x) {
                callback.failed(x);
            }
        }
    });
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Assert.assertArrayEquals(content, buffer.toByteArray());
}

Example 35 with MetaData

use of org.eclipse.jetty.http.MetaData in project jetty.project by eclipse.

the class AsyncServletTest method testStartAsyncThenClientStreamIdleTimeout.

@Test
public void testStartAsyncThenClientStreamIdleTimeout() throws Exception {
    CountDownLatch serverLatch = new CountDownLatch(1);
    start(new AsyncOnErrorServlet(serverLatch));
    long idleTimeout = 1000;
    client.setIdleTimeout(10 * idleTimeout);
    Session session = newClient(new Session.Listener.Adapter());
    HttpFields fields = new HttpFields();
    MetaData.Request metaData = newRequest("GET", fields);
    HeadersFrame frame = new HeadersFrame(metaData, null, true);
    FuturePromise<Stream> promise = new FuturePromise<>();
    CountDownLatch clientLatch = new CountDownLatch(1);
    session.newStream(frame, promise, new Stream.Listener.Adapter() {

        @Override
        public boolean onIdleTimeout(Stream stream, Throwable x) {
            clientLatch.countDown();
            return true;
        }
    });
    Stream stream = promise.get(5, TimeUnit.SECONDS);
    stream.setIdleTimeout(idleTimeout);
    // When the client resets, the server receives the
    // corresponding frame and acts by notifying the failure,
    // but the response is not sent back to the client.
    Assert.assertTrue(serverLatch.await(2 * idleTimeout, TimeUnit.MILLISECONDS));
    Assert.assertTrue(clientLatch.await(2 * idleTimeout, TimeUnit.MILLISECONDS));
}