Examples with Context io.vertx.core.Context used on opensource projects

Example 76 with Context

use of io.vertx.core.Context in project vert.x by eclipse.

the class Http2ServerTest method testStreamWritability.

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 -> {
        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();
}

Example 77 with Context

use of io.vertx.core.Context in project vert.x by eclipse.

the class Http2ServerTest method testStreamError.

@Test
public void testStreamError() throws Exception {
    waitFor(5);
    Future<Void> when = Future.future();
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {
        req.exceptionHandler(err -> {
            assertEquals(ctx, Vertx.currentContext());
            complete();
        });
        req.response().exceptionHandler(err -> {
            assertEquals(ctx, Vertx.currentContext());
            complete();
        });
        req.response().closeHandler(v -> {
            assertEquals(ctx, Vertx.currentContext());
            complete();
        });
        req.response().endHandler(v -> {
            assertEquals(ctx, Vertx.currentContext());
            complete();
        });
        when.complete();
    });
    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, false, request.context.newPromise());
        request.context.flush();
        when.setHandler(ar -> {
            request.channel.write(Buffer.buffer(new byte[] { 0x00, 0x00, 0x12, 0x00, 0x08, 0x00, 0x00, 0x00, (byte) (id & 0xFF), 0x1F, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }).getByteBuf());
            request.context.flush();
        });
    });
    fut.sync();
    await();
}

Example 78 with Context

use of io.vertx.core.Context in project vert.x by eclipse.

the class Http2ServerTest method testResetPendingPushPromise.

@Test
public void testResetPendingPushPromise() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {
        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();
}

Example 79 with Context

use of io.vertx.core.Context in project vert.x by eclipse.

the class Http2ServerTest method testConnectionClose.

@Test
public void testConnectionClose() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    server.requestHandler(req -> {
        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();
}

Example 80 with Context

use of io.vertx.core.Context in project vert.x by eclipse.

the class Http2ServerTest method testClientSettings.

@Test
public void testClientSettings() throws Exception {
    Context ctx = vertx.getOrCreateContext();
    io.vertx.core.http.Http2Settings initialSettings = TestUtils.randomHttp2Settings();
    io.vertx.core.http.Http2Settings updatedSettings = TestUtils.randomHttp2Settings();
    Future<Void> settingsRead = Future.future();
    AtomicInteger count = new AtomicInteger();
    server.connectionHandler(conn -> {
        io.vertx.core.http.Http2Settings settings = conn.remoteSettings();
        assertEquals(true, settings.isPushEnabled());
        assertEquals(io.vertx.core.http.Http2Settings.DEFAULT_MAX_FRAME_SIZE, settings.getMaxFrameSize());
        assertEquals(io.vertx.core.http.Http2Settings.DEFAULT_INITIAL_WINDOW_SIZE, settings.getInitialWindowSize());
        assertEquals((Long) (long) Integer.MAX_VALUE, (Long) (long) settings.getMaxConcurrentStreams());
        assertEquals(io.vertx.core.http.Http2Settings.DEFAULT_HEADER_TABLE_SIZE, settings.getHeaderTableSize());
        conn.remoteSettingsHandler(update -> {
            assertOnIOContext(ctx);
            switch(count.getAndIncrement()) {
                case 0:
                    assertEquals(initialSettings.isPushEnabled(), update.isPushEnabled());
                    assertEquals(initialSettings.getMaxHeaderListSize(), update.getMaxHeaderListSize());
                    assertEquals(initialSettings.getMaxFrameSize(), update.getMaxFrameSize());
                    assertEquals(initialSettings.getInitialWindowSize(), update.getInitialWindowSize());
                    assertEquals(initialSettings.getMaxConcurrentStreams(), update.getMaxConcurrentStreams());
                    assertEquals(initialSettings.getHeaderTableSize(), update.getHeaderTableSize());
                    assertEquals(initialSettings.get(''), update.get(7));
                    settingsRead.complete();
                    break;
                case 1:
                    assertEquals(updatedSettings.isPushEnabled(), update.isPushEnabled());
                    assertEquals(updatedSettings.getMaxHeaderListSize(), update.getMaxHeaderListSize());
                    assertEquals(updatedSettings.getMaxFrameSize(), update.getMaxFrameSize());
                    assertEquals(updatedSettings.getInitialWindowSize(), update.getInitialWindowSize());
                    assertEquals(updatedSettings.getMaxConcurrentStreams(), update.getMaxConcurrentStreams());
                    assertEquals(updatedSettings.getHeaderTableSize(), update.getHeaderTableSize());
                    assertEquals(updatedSettings.get(''), update.get(7));
                    testComplete();
                    break;
            }
        });
    });
    server.requestHandler(req -> {
        fail();
    });
    startServer(ctx);
    TestClient client = new TestClient();
    client.settings.putAll(HttpUtils.fromVertxSettings(initialSettings));
    ChannelFuture fut = client.connect(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, request -> {
        settingsRead.setHandler(ar -> {
            request.encoder.writeSettings(request.context, HttpUtils.fromVertxSettings(updatedSettings), request.context.newPromise());
            request.context.flush();
        });
    });
    fut.sync();
    await();
}