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

Example 11 with Handler

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

the class Http2ServerTest method testServerSendGoAwayNoError.

@Test
public void testServerSendGoAwayNoError() throws Exception {
    waitFor(2);
    AtomicReference<HttpServerRequest> first = new AtomicReference<>();
    AtomicInteger status = new AtomicInteger();
    AtomicInteger closed = new AtomicInteger();
    AtomicBoolean done = new AtomicBoolean();
    Context ctx = vertx.getOrCreateContext();
    Handler<HttpServerRequest> requestHandler = req -> {
        if (first.compareAndSet(null, req)) {
            req.exceptionHandler(err -> {
                assertTrue(done.get());
            });
            req.response().exceptionHandler(err -> {
                assertTrue(done.get());
            });
        } else {
            assertEquals(0, status.getAndIncrement());
            req.exceptionHandler(err -> {
                closed.incrementAndGet();
            });
            req.response().exceptionHandler(err -> {
                closed.incrementAndGet();
            });
            HttpConnection conn = req.connection();
            conn.shutdownHandler(v -> {
                assertTrue(done.get());
            });
            conn.closeHandler(v -> {
                assertTrue(done.get());
            });
            ctx.runOnContext(v1 -> {
                conn.goAway(0, first.get().response().streamId());
                vertx.setTimer(300, timerID -> {
                    assertEquals(1, status.getAndIncrement());
                    done.set(true);
                    complete();
                });
            });
        }
    };
    testServerSendGoAway(requestHandler, 0);
}

Example 12 with Handler

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

the class Http2ServerTest method testShutdown.

@Test
public void testShutdown() throws Exception {
    waitFor(2);
    AtomicReference<HttpServerRequest> first = new AtomicReference<>();
    AtomicInteger status = new AtomicInteger();
    Handler<HttpServerRequest> requestHandler = req -> {
        if (first.compareAndSet(null, req)) {
            req.exceptionHandler(err -> {
                fail();
            });
            req.response().exceptionHandler(err -> {
                fail();
            });
        } else {
            assertEquals(0, status.getAndIncrement());
            req.exceptionHandler(err -> {
                fail();
            });
            req.response().exceptionHandler(err -> {
                fail();
            });
            HttpConnection conn = req.connection();
            conn.closeHandler(v -> {
                assertEquals(2, status.getAndIncrement());
                complete();
            });
            conn.shutdown();
            vertx.setTimer(300, timerID -> {
                assertEquals(1, status.getAndIncrement());
                first.get().response().end();
                req.response().end();
            });
        }
    };
    testServerSendGoAway(requestHandler, 0);
}

Example 13 with Handler

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

the class HttpProxy method start.

/**
   * Start the server.
   * 
   * @param vertx
   *          Vertx instance to use for creating the server and client
   * @param finishedHandler
   *          will be called when the server has started
   */
@Override
public void start(Vertx vertx, Handler<Void> finishedHandler) {
    HttpServerOptions options = new HttpServerOptions();
    options.setHost("localhost").setPort(PORT);
    server = vertx.createHttpServer(options);
    server.requestHandler(request -> {
        HttpMethod method = request.method();
        String uri = request.uri();
        if (username != null) {
            String auth = request.getHeader("Proxy-Authorization");
            String expected = "Basic " + Base64.getEncoder().encodeToString((username + ":" + username).getBytes());
            if (auth == null || !auth.equals(expected)) {
                request.response().setStatusCode(407).end("proxy authentication failed");
                return;
            }
        }
        lastRequestHeaders = MultiMap.caseInsensitiveMultiMap().addAll(request.headers());
        if (error != 0) {
            request.response().setStatusCode(error).end("proxy request failed");
        } else if (method == HttpMethod.CONNECT) {
            if (!uri.contains(":")) {
                request.response().setStatusCode(403).end("invalid request");
            } else {
                lastUri = uri;
                if (forceUri != null) {
                    uri = forceUri;
                }
                String[] split = uri.split(":");
                String host = split[0];
                int port;
                try {
                    port = Integer.parseInt(split[1]);
                } catch (NumberFormatException ex) {
                    port = 443;
                }
                if (port == 8080 || port < 1024 && port != 443) {
                    request.response().setStatusCode(403).end("access to port denied");
                    return;
                }
                NetSocket serverSocket = request.netSocket();
                NetClientOptions netOptions = new NetClientOptions();
                NetClient netClient = vertx.createNetClient(netOptions);
                netClient.connect(port, host, result -> {
                    if (result.succeeded()) {
                        NetSocket clientSocket = result.result();
                        serverSocket.write("HTTP/1.0 200 Connection established\n\n");
                        serverSocket.closeHandler(v -> clientSocket.close());
                        clientSocket.closeHandler(v -> serverSocket.close());
                        Pump.pump(serverSocket, clientSocket).start();
                        Pump.pump(clientSocket, serverSocket).start();
                    } else {
                        request.response().setStatusCode(403).end("request failed");
                    }
                });
            }
        } else if (method == HttpMethod.GET) {
            lastUri = request.uri();
            HttpClient client = vertx.createHttpClient();
            HttpClientRequest clientRequest = client.getAbs(request.uri(), resp -> {
                for (String name : resp.headers().names()) {
                    request.response().putHeader(name, resp.headers().getAll(name));
                }
                resp.bodyHandler(body -> {
                    request.response().end(body);
                });
            });
            for (String name : request.headers().names()) {
                if (!name.equals("Proxy-Authorization")) {
                    clientRequest.putHeader(name, request.headers().getAll(name));
                }
            }
            clientRequest.exceptionHandler(e -> {
                log.debug("exception", e);
                int status;
                if (e instanceof UnknownHostException) {
                    status = 504;
                } else {
                    status = 400;
                }
                request.response().setStatusCode(status).end(e.toString() + " on client request");
            });
            clientRequest.end();
        } else {
            request.response().setStatusCode(405).end("method not supported");
        }
    });
    server.listen(server -> {
        finishedHandler.handle(null);
    });
}

Example 14 with Handler

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

the class HttpTest method sendFile.

private void sendFile(String fileName, String contentExpected, boolean handler) throws Exception {
    File fileToSend = setupFile(fileName, contentExpected);
    CountDownLatch latch;
    if (handler) {
        latch = new CountDownLatch(2);
    } else {
        latch = new CountDownLatch(1);
    }
    server.requestHandler(req -> {
        if (handler) {
            Handler<AsyncResult<Void>> completionHandler = onSuccess(v -> latch.countDown());
            req.response().sendFile(fileToSend.getAbsolutePath(), completionHandler);
        } else {
            req.response().sendFile(fileToSend.getAbsolutePath());
        }
    });
    server.listen(onSuccess(s -> {
        client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
            assertEquals(200, resp.statusCode());
            assertEquals("text/html", resp.headers().get("Content-Type"));
            resp.bodyHandler(buff -> {
                assertEquals(contentExpected, buff.toString());
                assertEquals(fileToSend.length(), Long.parseLong(resp.headers().get("content-length")));
                latch.countDown();
            });
        }).end();
    }));
    assertTrue("Timed out waiting for test to complete.", latch.await(10, TimeUnit.SECONDS));
    testComplete();
}

Example 15 with Handler

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

the class Http2ServerTest method testServerSendGoAwayInteralError.

@Test
public void testServerSendGoAwayInteralError() throws Exception {
    waitFor(3);
    AtomicReference<HttpServerRequest> first = new AtomicReference<>();
    AtomicInteger status = new AtomicInteger();
    AtomicInteger closed = new AtomicInteger();
    Handler<HttpServerRequest> requestHandler = req -> {
        if (first.compareAndSet(null, req)) {
            req.exceptionHandler(err -> {
                fail();
            });
            req.response().closeHandler(err -> {
                closed.incrementAndGet();
            });
            req.response().endHandler(err -> {
                closed.incrementAndGet();
            });
        } else {
            assertEquals(0, status.getAndIncrement());
            req.exceptionHandler(err -> {
                closed.incrementAndGet();
            });
            req.response().closeHandler(err -> {
                closed.incrementAndGet();
            });
            req.response().endHandler(err -> {
                closed.incrementAndGet();
            });
            HttpConnection conn = req.connection();
            conn.closeHandler(v -> {
                assertEquals(5, closed.get());
                assertEquals(1, status.get());
                complete();
            });
            conn.shutdownHandler(v -> {
                assertEquals(1, status.get());
                complete();
            });
            conn.goAway(2, first.get().response().streamId());
        }
    };
    testServerSendGoAway(requestHandler, 2);
}