Example usage for io.netty.handler.codec.http2 Http2FrameAdapter Http2FrameAdapter

Introduction

In this page you can find the example usage for io.netty.handler.codec.http2 Http2FrameAdapter Http2FrameAdapter.

Prototype

Http2FrameAdapter

Source Link

Usage

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testServerInitialSettings() throws Exception {
    io.vertx.core.http.Http2Settings settings = TestUtils.randomHttp2Settings();
    server.close();//from   ww w . j a v a 2  s  .com
    server = vertx.createHttpServer(serverOptions.setInitialSettings(settings));
    server.requestHandler(req -> fail());
    startServer();
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public void onSettingsRead(ChannelHandlerContext ctx, Http2Settings newSettings)
                    throws Http2Exception {
                vertx.runOnContext(v -> {
                    assertEquals((Long) settings.getHeaderTableSize(), newSettings.headerTableSize());
                    assertEquals((Long) settings.getMaxConcurrentStreams(), newSettings.maxConcurrentStreams());
                    assertEquals((Integer) settings.getInitialWindowSize(), newSettings.initialWindowSize());
                    assertEquals((Integer) settings.getMaxFrameSize(), newSettings.maxFrameSize());
                    assertEquals((Long) settings.getMaxHeaderListSize(), newSettings.maxHeaderListSize());
                    assertEquals(settings.get('\u0007'), newSettings.get('\u0007'));
                    testComplete();
                });
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testServerSettings() throws Exception {
    waitFor(2);/*from w w w. ja va 2 s  . co m*/
    io.vertx.core.http.Http2Settings expectedSettings = TestUtils.randomHttp2Settings();
    expectedSettings.setHeaderTableSize((int) io.vertx.core.http.Http2Settings.DEFAULT_HEADER_TABLE_SIZE);
    Context otherContext = vertx.getOrCreateContext();
    server.connectionHandler(conn -> {
        Context ctx = Vertx.currentContext();
        otherContext.runOnContext(v -> {
            conn.updateSettings(expectedSettings, ar -> {
                assertSame(ctx, Vertx.currentContext());
                io.vertx.core.http.Http2Settings ackedSettings = conn.settings();
                assertEquals(expectedSettings.getMaxHeaderListSize(), ackedSettings.getMaxHeaderListSize());
                assertEquals(expectedSettings.getMaxFrameSize(), ackedSettings.getMaxFrameSize());
                assertEquals(expectedSettings.getInitialWindowSize(), ackedSettings.getInitialWindowSize());
                assertEquals(expectedSettings.getMaxConcurrentStreams(),
                        ackedSettings.getMaxConcurrentStreams());
                assertEquals(expectedSettings.getHeaderTableSize(), ackedSettings.getHeaderTableSize());
                assertEquals(expectedSettings.get('\u0007'), ackedSettings.get(7));
                complete();
            });
        });
    });
    server.requestHandler(req -> {
        fail();
    });
    startServer();
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        request.decoder.frameListener(new Http2FrameAdapter() {
            AtomicInteger count = new AtomicInteger();
            Context context = vertx.getOrCreateContext();

            @Override
            public void onSettingsRead(ChannelHandlerContext ctx, Http2Settings newSettings)
                    throws Http2Exception {
                context.runOnContext(v -> {
                    switch (count.getAndIncrement()) {
                    case 0:
                        // Initial settings
                        break;
                    case 1:
                        // Server sent settings
                        assertEquals((Long) expectedSettings.getMaxHeaderListSize(),
                                newSettings.maxHeaderListSize());
                        assertEquals((Integer) expectedSettings.getMaxFrameSize(), newSettings.maxFrameSize());
                        assertEquals((Integer) expectedSettings.getInitialWindowSize(),
                                newSettings.initialWindowSize());
                        assertEquals((Long) expectedSettings.getMaxConcurrentStreams(),
                                newSettings.maxConcurrentStreams());
                        assertEquals(null, newSettings.headerTableSize());
                        complete();
                        break;
                    default:
                        fail();
                    }
                });
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

private void testStreamWritability(Function<HttpServerRequest, WriteStream<Buffer>> streamProvider)
        throws Exception {
    Context ctx = vertx.getOrCreateContext();
    String content = TestUtils.randomAlphaString(1024);
    StringBuilder expected = new StringBuilder();
    Future<Void> whenFull = Future.future();
    AtomicBoolean drain = new AtomicBoolean();
    server.requestHandler(req -> {/*from   w w w  . j  ava  2 s . c o m*/
        WriteStream<Buffer> stream = streamProvider.apply(req);
        vertx.setPeriodic(1, timerID -> {
            if (stream.writeQueueFull()) {
                stream.drainHandler(v -> {
                    assertOnIOContext(ctx);
                    expected.append("last");
                    stream.end(Buffer.buffer("last"));
                });
                vertx.cancelTimer(timerID);
                drain.set(true);
                whenFull.complete();
            } else {
                expected.append(content);
                Buffer buf = Buffer.buffer(content);
                stream.write(buf);
            }
        });
    });
    startServer(ctx);

    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        AtomicInteger toAck = new AtomicInteger();
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, GET("/"), 0, true, request.context.newPromise());
        request.decoder.frameListener(new Http2FrameAdapter() {

            StringBuilder received = new StringBuilder();

            @Override
            public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding,
                    boolean endOfStream) throws Http2Exception {
                received.append(data.toString(StandardCharsets.UTF_8));
                int delta = super.onDataRead(ctx, streamId, data, padding, endOfStream);
                if (endOfStream) {
                    vertx.runOnContext(v -> {
                        assertEquals(expected.toString(), received.toString());
                        testComplete();
                    });
                    return delta;
                } else {
                    if (drain.get()) {
                        return delta;
                    } else {
                        toAck.getAndAdd(delta);
                        return 0;
                    }
                }
            }
        });
        whenFull.setHandler(ar -> {
            request.context.executor().execute(() -> {
                try {
                    request.decoder.flowController().consumeBytes(request.connection.stream(id),
                            toAck.intValue());
                    request.context.flush();
                } catch (Http2Exception e) {
                    e.printStackTrace();
                    fail(e);
                }
            });
        });
    });

    fut.sync();

    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testConnectionClose() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {//from ww  w  .  jav  a 2  s .c o  m
        HttpConnection conn = req.connection();
        conn.closeHandler(v -> {
            assertSame(ctx, Vertx.currentContext());
            testComplete();
        });
        req.response().putHeader("Content-Type", "text/plain").end();
    });
    startServer(ctx);

    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, GET("/"), 0, true, request.context.newPromise());
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers,
                    int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)
                    throws Http2Exception {
                request.context.close();
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

private void testPushPromise(Http2Headers requestHeaders,
        BiConsumer<HttpServerResponse, Handler<AsyncResult<HttpServerResponse>>> pusher,
        Consumer<Http2Headers> headerChecker) throws Exception {
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {//  w w  w.ja va2 s  . c o m
        Handler<AsyncResult<HttpServerResponse>> handler = ar -> {
            assertSame(ctx, Vertx.currentContext());
            assertTrue(ar.succeeded());
            HttpServerResponse response = ar.result();
            response./*putHeader("content-type", "application/plain").*/end("the_content");
            assertIllegalStateException(() -> response.push(HttpMethod.GET, "/wibble2", resp -> {
            }));
        };
        pusher.accept(req.response(), handler);
    });
    startServer(ctx);
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, requestHeaders, 0, true, request.context.newPromise());
        Map<Integer, Http2Headers> pushed = new HashMap<>();
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public void onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId,
                    Http2Headers headers, int padding) throws Http2Exception {
                pushed.put(promisedStreamId, headers);
            }

            @Override
            public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding,
                    boolean endOfStream) throws Http2Exception {
                int delta = super.onDataRead(ctx, streamId, data, padding, endOfStream);
                String content = data.toString(StandardCharsets.UTF_8);
                vertx.runOnContext(v -> {
                    assertEquals(Collections.singleton(streamId), pushed.keySet());
                    assertEquals("the_content", content);
                    Http2Headers pushedHeaders = pushed.get(streamId);
                    headerChecker.accept(pushedHeaders);
                    testComplete();
                });
                return delta;
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testResetActivePushPromise() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {// w ww .  ja  va  2 s.c o  m
        req.response().push(HttpMethod.GET, "/wibble", ar -> {
            assertTrue(ar.succeeded());
            assertOnIOContext(ctx);
            HttpServerResponse response = ar.result();
            AtomicInteger resets = new AtomicInteger();
            response.exceptionHandler(err -> {
                if (err instanceof StreamResetException) {
                    assertEquals(8, ((StreamResetException) err).getCode());
                    resets.incrementAndGet();
                }
            });
            response.closeHandler(v -> {
                testComplete();
                assertEquals(1, resets.get());
            });
            response.setChunked(true).write("some_content");
        });
    });
    startServer(ctx);
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, GET("/"), 0, true, request.context.newPromise());
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding,
                    boolean endOfStream) throws Http2Exception {
                request.encoder.writeRstStream(ctx, streamId, Http2Error.CANCEL.code(), ctx.newPromise());
                request.context.flush();
                return super.onDataRead(ctx, streamId, data, padding, endOfStream);
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testQueuePushPromise() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    int numPushes = 10;
    Set<String> pushSent = new HashSet<>();
    server.requestHandler(req -> {/*from w  ww. j  a  va 2  s. com*/
        req.response().setChunked(true).write("abc");
        for (int i = 0; i < numPushes; i++) {
            int val = i;
            String path = "/wibble" + val;
            req.response().push(HttpMethod.GET, path, ar -> {
                assertTrue(ar.succeeded());
                assertSame(ctx, Vertx.currentContext());
                pushSent.add(path);
                vertx.setTimer(10, id -> {
                    ar.result().end("wibble-" + val);
                });
            });
        }
    });
    startServer(ctx);
    TestClient client = new TestClient();
    client.settings.maxConcurrentStreams(3);
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, GET("/"), 0, true, request.context.newPromise());
        request.decoder.frameListener(new Http2FrameAdapter() {
            int count = numPushes;
            Set<String> pushReceived = new HashSet<>();

            @Override
            public void onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId,
                    Http2Headers headers, int padding) throws Http2Exception {
                pushReceived.add(headers.path().toString());
            }

            @Override
            public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding,
                    boolean endOfStream) throws Http2Exception {
                if (count-- == 0) {
                    vertx.runOnContext(v -> {
                        assertEquals(numPushes, pushSent.size());
                        assertEquals(pushReceived, pushSent);
                        testComplete();
                    });
                }
                return super.onDataRead(ctx, streamId, data, padding, endOfStream);
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testResetPendingPushPromise() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {// w  w  w.  jav a2 s  .co m
        req.response().push(HttpMethod.GET, "/wibble", ar -> {
            assertFalse(ar.succeeded());
            assertOnIOContext(ctx);
            testComplete();
        });
    });
    startServer(ctx);
    TestClient client = new TestClient();
    client.settings.maxConcurrentStreams(0);
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, GET("/"), 0, true, request.context.newPromise());
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public void onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId,
                    Http2Headers headers, int padding) throws Http2Exception {
                request.encoder.writeRstStream(request.context, promisedStreamId, Http2Error.CANCEL.code(),
                        request.context.newPromise());
                request.context.flush();
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

private void testMalformedRequestHeaders(Http2Headers headers) throws Exception {
    server.requestHandler(req -> fail());
    startServer();//from  ww  w  . j  a  v a  2s.co m
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        Http2ConnectionEncoder encoder = request.encoder;
        encoder.writeHeaders(request.context, id, headers, 0, true, request.context.newPromise());
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public void onRstStreamRead(ChannelHandlerContext ctx, int streamId, long errorCode)
                    throws Http2Exception {
                vertx.runOnContext(v -> {
                    testComplete();
                });
            }
        });
    });
    fut.sync();
    await();
}

---

From source file:io.vertx.core.http.Http2ServerTest.java

License:Open Source License

@Test
public void testStreamPriority() throws Exception {
    StreamPriority requestStreamPriority = new StreamPriority().setDependency(123).setWeight((short) 45)
            .setExclusive(true);//ww  w  .j  a  v  a 2  s  .co m
    StreamPriority responseStreamPriority = new StreamPriority().setDependency(153).setWeight((short) 75)
            .setExclusive(false);
    waitFor(3);
    server.requestHandler(req -> {
        HttpServerResponse resp = req.response();
        assertEquals(requestStreamPriority, req.streamPriority());
        resp.setStatusCode(200);
        resp.setStreamPriority(responseStreamPriority);
        resp.end("data");
        complete();
    });
    startServer();
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        request.encoder.writeHeaders(request.context, id, GET("/"), requestStreamPriority.getDependency(),
                requestStreamPriority.getWeight(), requestStreamPriority.isExclusive(), 0, true,
                request.context.newPromise());
        request.context.flush();
        request.decoder.frameListener(new Http2FrameAdapter() {
            @Override
            public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers,
                    int streamDependency, short weight, boolean exclusive, int padding, boolean endStream)
                    throws Http2Exception {
                super.onHeadersRead(ctx, streamId, headers, streamDependency, weight, exclusive, padding,
                        endStream);
                vertx.runOnContext(v -> {
                    assertEquals(id, streamId);
                    assertEquals(responseStreamPriority.getDependency(), streamDependency);
                    assertEquals(responseStreamPriority.getWeight(), weight);
                    assertEquals(responseStreamPriority.isExclusive(), exclusive);
                    complete();
                });
            }

            @Override
            public void onPriorityRead(ChannelHandlerContext ctx, int streamId, int streamDependency,
                    short weight, boolean exclusive) throws Http2Exception {
                vertx.runOnContext(v -> {
                    fail("Priority frame should not be sent");
                });
            }

            @Override
            public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding,
                    boolean endOfStream) throws Http2Exception {
                if (endOfStream) {
                    vertx.runOnContext(v -> {
                        complete();
                    });
                }
                return super.onDataRead(ctx, streamId, data, padding, endOfStream);
            }
        });
    });
    fut.sync();
    await();
}

---

• «
• 1
• 2
• »