Examples with Http2EventAdapter io.netty.handler.codec.http2.Http2EventAdapter used on opensource projects

Example 26 with Http2EventAdapter

use of io.netty.handler.codec.http2.Http2EventAdapter in project vert.x by eclipse.

the class Http2ServerTest method test100ContinueRejectedManually.

@Test
public void test100ContinueRejectedManually() throws Exception {
    server.requestHandler(req -> {
        req.response().setStatusCode(405).end();
        req.handler(buf -> {
            fail();
        });
    });
    startServer();
    TestClient client = new TestClient();
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        int id = request.nextStreamId();
        request.decoder.frameListener(new Http2EventAdapter() {

            int count = 0;

            @Override
            public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream) throws Http2Exception {
                switch(count++) {
                    case 0:
                        vertx.runOnContext(v -> {
                            assertEquals("405", headers.status().toString());
                            vertx.setTimer(100, v2 -> {
                                testComplete();
                            });
                        });
                        break;
                    default:
                        vertx.runOnContext(v -> {
                            fail();
                        });
                }
            }
        });
        request.encoder.writeHeaders(request.context, id, GET("/").add("expect", "100-continue"), 0, false, request.context.newPromise());
        request.context.flush();
    });
    fut.sync();
    await();
}

Example 27 with Http2EventAdapter

use of io.netty.handler.codec.http2.Http2EventAdapter in project vert.x by eclipse.

the class Http2ClientTest method testStreamPriority.

/*
  @Test
  public void testFillsSingleConnection() throws Exception {

    Set<HttpConnection> serverConns = new HashSet<>();
    List<HttpServerRequest> requests = new ArrayList<>();
    server.requestHandler(req -> {
      requests.add(req);
      serverConns.add(req.connection());
      if (requests.size() == 10) {
        System.out.println("requestsPerConn = " + serverConns);
      }
    });
    startServer();

    client.close();
    client = vertx.createHttpClient(new HttpClientOptions(clientOptions).
        setHttp2MaxPoolSize(2).
        setHttp2MaxStreams(10));
    AtomicInteger respCount = new AtomicInteger();
    for (int i = 0;i < 10;i++) {
      client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> {
        resp.endHandler(v -> {
        });
      });
    }
    await();
  }
*/
@Test
public void testStreamPriority() throws Exception {
    StreamPriority requestStreamPriority = new StreamPriority().setDependency(123).setWeight((short) 45).setExclusive(true);
    StreamPriority responseStreamPriority = new StreamPriority().setDependency(153).setWeight((short) 75).setExclusive(false);
    waitFor(2);
    ServerBootstrap bootstrap = createH2Server((decoder, encoder) -> new Http2EventAdapter() {

        @Override
        public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream) throws Http2Exception {
            vertx.runOnContext(v -> {
                assertEquals(requestStreamPriority.getDependency(), streamDependency);
                assertEquals(requestStreamPriority.getWeight(), weight);
                assertEquals(requestStreamPriority.isExclusive(), exclusive);
                encoder.writeHeaders(ctx, streamId, new DefaultHttp2Headers().status("200"), responseStreamPriority.getDependency(), responseStreamPriority.getWeight(), responseStreamPriority.isExclusive(), 0, true, ctx.newPromise());
                ctx.flush();
                if (endStream)
                    complete();
            });
        }
    });
    ChannelFuture s = bootstrap.bind(DEFAULT_HTTPS_HOST, DEFAULT_HTTPS_PORT).sync();
    try {
        client.request(requestOptions).onComplete(onSuccess(req -> {
            req.setStreamPriority(requestStreamPriority).send(onSuccess(resp -> {
                assertEquals(responseStreamPriority, resp.request().getStreamPriority());
                Context ctx = vertx.getOrCreateContext();
                assertOnIOContext(ctx);
                resp.endHandler(v -> {
                    complete();
                });
            }));
        }));
        await();
    } finally {
        s.channel().close().sync();
    }
}

Example 28 with Http2EventAdapter

use of io.netty.handler.codec.http2.Http2EventAdapter in project vert.x by eclipse.

the class Http2ClientTest method testServerStreamPriorityNoChange.

@Ignore("Cannot pass reliably for now (https://github.com/netty/netty/issues/9842)")
@Test
public void testServerStreamPriorityNoChange() throws Exception {
    StreamPriority streamPriority = new StreamPriority().setDependency(123).setWeight((short) 45).setExclusive(true);
    waitFor(1);
    ServerBootstrap bootstrap = createH2Server((decoder, encoder) -> new Http2EventAdapter() {

        @Override
        public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream) throws Http2Exception {
            encoder.writeHeaders(ctx, streamId, new DefaultHttp2Headers().status("200"), streamPriority.getDependency(), streamPriority.getWeight(), streamPriority.isExclusive(), 0, false, ctx.newPromise());
            encoder.writePriority(ctx, streamId, streamPriority.getDependency(), streamPriority.getWeight(), streamPriority.isExclusive(), ctx.newPromise());
            encoder.writeData(ctx, streamId, Buffer.buffer("hello").getByteBuf(), 0, true, ctx.newPromise());
            ctx.flush();
        }

        @Override
        public void onPriorityRead(ChannelHandlerContext ctx, int streamId, int streamDependency, short weight, boolean exclusive) throws Http2Exception {
            fail("Priority frame should not be sent");
        }
    });
    ChannelFuture s = bootstrap.bind(DEFAULT_HTTPS_HOST, DEFAULT_HTTPS_PORT).sync();
    try {
        client.request(requestOptions).onComplete(onSuccess(req -> {
            req.send(onSuccess(resp -> {
                assertEquals(streamPriority, resp.request().getStreamPriority());
                Context ctx = vertx.getOrCreateContext();
                assertOnIOContext(ctx);
                resp.streamPriorityHandler(priority -> fail("Stream priority handler should not be called"));
                resp.endHandler(v -> {
                    assertEquals(streamPriority, resp.request().getStreamPriority());
                    complete();
                });
            }));
        }));
        await();
    } finally {
        s.channel().close().sync();
    }
}

Example 29 with Http2EventAdapter

use of io.netty.handler.codec.http2.Http2EventAdapter in project vert.x by eclipse.

the class Http2ClientTest method testStreamError.

@Test
public void testStreamError() throws Exception {
    waitFor(3);
    ServerBootstrap bootstrap = createH2Server((dec, enc) -> new Http2EventAdapter() {

        @Override
        public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream) throws Http2Exception {
            enc.writeHeaders(ctx, streamId, new DefaultHttp2Headers().status("200"), 0, false, ctx.newPromise());
            // Send a corrupted frame on purpose to check we get the corresponding error in the request exception handler
            // the error is : greater padding value 0c -> 1F
            // ChannelFuture a = encoder.frameWriter().writeData(request.context, id, Buffer.buffer("hello").getByteBuf(), 12, false, request.context.newPromise());
            // normal frame    : 00 00 12 00 08 00 00 00 03 0c 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00
            // corrupted frame : 00 00 12 00 08 00 00 00 03 1F 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00
            ctx.channel().write(Buffer.buffer(new byte[] { 0x00, 0x00, 0x12, 0x00, 0x08, 0x00, 0x00, 0x00, (byte) (streamId & 0xFF), 0x1F, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }).getByteBuf());
            ctx.flush();
        }
    });
    ChannelFuture s = bootstrap.bind(DEFAULT_HTTPS_HOST, DEFAULT_HTTPS_PORT).sync();
    try {
        client.close();
        Context ctx = vertx.getOrCreateContext();
        ctx.runOnContext(v -> {
            client = vertx.createHttpClient(createBaseClientOptions());
            client.connectionHandler(conn -> {
                conn.exceptionHandler(err -> {
                    assertOnIOContext(ctx);
                    if (err instanceof Http2Exception) {
                        complete();
                    }
                });
            });
            client.request(new RequestOptions().setMethod(HttpMethod.PUT).setHost(DEFAULT_HTTPS_HOST).setPort(DEFAULT_HTTPS_PORT).setURI(DEFAULT_TEST_URI)).onComplete(onSuccess(req -> {
                req.response(onSuccess(resp -> {
                    resp.exceptionHandler(err -> {
                        assertOnIOContext(ctx);
                        if (err instanceof Http2Exception) {
                            complete();
                        }
                    });
                })).exceptionHandler(err -> {
                    assertOnIOContext(ctx);
                    if (err instanceof Http2Exception) {
                        complete();
                    }
                }).sendHead();
            }));
        });
        await();
    } finally {
        s.channel().close().sync();
    }
}

Example 30 with Http2EventAdapter

use of io.netty.handler.codec.http2.Http2EventAdapter in project vert.x by eclipse.

the class Http2ClientTest method testGet.

@Test
public void testGet() throws Exception {
    ServerBootstrap bootstrap = createH2Server((decoder, encoder) -> new Http2EventAdapter() {

        @Override
        public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endStream) throws Http2Exception {
            vertx.runOnContext(v -> {
                assertTrue(endStream);
                encoder.writeHeaders(ctx, streamId, new DefaultHttp2Headers().status("200"), 0, true, ctx.newPromise());
                ctx.flush();
            });
        }

        @Override
        public void onGoAwayRead(ChannelHandlerContext ctx, int lastStreamId, long errorCode, ByteBuf debugData) throws Http2Exception {
            vertx.runOnContext(v -> {
                testComplete();
            });
        }
    });
    ChannelFuture s = bootstrap.bind(DEFAULT_HTTPS_HOST, DEFAULT_HTTPS_PORT).sync();
    try {
        client.request(requestOptions).onComplete(onSuccess(req -> {
            req.send(onSuccess(resp -> {
                Context ctx = vertx.getOrCreateContext();
                assertOnIOContext(ctx);
                resp.endHandler(v -> {
                    assertOnIOContext(ctx);
                    resp.request().connection().close();
                });
            }));
        }));
        await();
    } finally {
        s.channel().close().sync();
    }
}