@Override public void start() throws Exception { Router router = Router.router(vertx); router.route().handler(routingContext -> { routingContext.response().putHeader("content-type", "text/html").end("Hello World!"); }); vertx.createHttpServer().requestHandler(router).listen(8080); } }
@Override public void start() throws Exception { Router router = Router.router(vertx); router.route().handler(BodyHandler.create()); router.route().handler(req -> req.response().putHeader("content-type", "text/html") .end("<html><body><h1>Hello from vert.x!</h1></body></html>")); HttpServer server = vertx.createHttpServer(); server.requestStream() .toFlowable() .map(HttpServerRequest::pause) .onBackpressureDrop(req -> req.response().setStatusCode(503).end()) .observeOn(RxHelper.scheduler(vertx.getDelegate())) .subscribe(req -> { req.resume(); router.accept(req); }); server.rxListen(PORT).subscribe(res -> generateRequests()); }
@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(); server.requestStream().toFlowable().subscribe(req -> { req.response().putHeader("content-type", "application/json").end(new JsonObject().put("time", System.currentTimeMillis()).toString()); }); server.listen(8080); } }
/** * Create an HTTP server for the REST service. * * @param router router instance * @param host server host * @param port server port * @return asynchronous result */ protected Completable createHttpServer(Router router, String host, int port) { return vertx.createHttpServer() .requestHandler(router::accept) .rxListen(port, host) .toCompletable(); }
httpServer.requestStream().toFlowable() .map(HttpServerRequest::pause) .onBackpressureBuffer(options.getBackpressureBufferCapacity(), } else { httpServer .requestHandler(req -> routeSafe(req, router)); httpServer.rxListen().subscribe(ok -> { LOGGER.info("Knot.x HTTP Server started. Listening on port {}", options.getServerOptions().getPort());
private Completable startVertx(VertxResteasyDeployment deployment) { return Completable.defer(() -> { Router router = Router.router(vertx); AppGlobals globals = AppGlobals.get(); globals.setRouter(router); VertxPluginRequestHandler resteasyHandler = new VertxPluginRequestHandler(vertx, deployment, plugins); return doOnPlugins(plugin -> plugin.preRoute()) .doOnComplete(() -> { setupRoutes(router); router.route().handler(routingContext -> { ResteasyProviderFactory.pushContext(RoutingContext.class, routingContext); ResteasyProviderFactory.pushContext(io.vertx.rxjava.ext.web.RoutingContext.class, io.vertx.rxjava.ext.web.RoutingContext.newInstance(routingContext.getDelegate())); resteasyHandler.handle(routingContext.request()); }); }).concatWith(doOnPlugins(plugin -> plugin.postRoute())) .concatWith(Completable.defer(() -> { // Start the front end server using the Jax-RS controller int port = globals.getConfig().getInteger("http_port", 9000); String host = globals.getConfig().getString("http_host", NetServerOptions.DEFAULT_HOST); return vertx.createHttpServer() .requestHandler(router::accept) .rxListen(port, host) .doOnSuccess(server -> System.out.println("Server started on port " + server.actualPort())) .doOnError(t -> t.printStackTrace()) .ignoreElement(); })); }); }
@Test public void testResponseBodyAsAsJsonMapped() throws Exception { JsonObject expected = new JsonObject().put("cheese", "Goat Cheese").put("wine", "Condrieu"); HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080)); server.requestStream().handler(req -> req.response().end(expected.encode())); try { server.listen(ar -> { client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions())); Single<HttpResponse<WineAndCheese>> single = client .get(8080, "localhost", "/the_uri") .as(BodyCodec.json(WineAndCheese.class)) .rxSend(); single.subscribe(resp -> { assertEquals(200, resp.statusCode()); assertEquals(new WineAndCheese().setCheese("Goat Cheese").setWine("Condrieu"), resp.body()); testComplete(); }, this::fail); }); await(); } finally { server.close(); } }
@Override public void stop() throws Exception { logger.info("Stopping HTTP Server..."); httpServer.close(voidAsyncResult -> logger.info("HTTP Server has been correctly stopped")); } }
private Completable createHttpServer(JsonObject config, Router router) { return vertx .createHttpServer() .requestHandler(router::accept) .rxListen(config.getInteger("HTTP_PORT", 8080)) .toCompletable(); }
httpServer.requestStream().toFlowable() .map(HttpServerRequest::pause) .onBackpressureBuffer(options.getBackpressureBufferCapacity(), } else { httpServer .requestHandler(req -> routeSafe(req, router)); httpServer.rxListen().subscribe(ok -> { LOGGER.info("Knot.x HTTP Server started. Listening on port {}", options.getServerOptions().getPort());
private Completable startVertx(VertxResteasyDeployment deployment) { return Completable.defer(() -> { Router router = Router.router(vertx); AppGlobals globals = AppGlobals.get(); globals.setRouter(router); VertxPluginRequestHandler resteasyHandler = new VertxPluginRequestHandler(vertx, deployment, plugins); return doOnPlugins(plugin -> plugin.preRoute()) .doOnComplete(() -> { setupRoutes(router); router.route().handler(routingContext -> { ResteasyProviderFactory.pushContext(RoutingContext.class, routingContext); ResteasyProviderFactory.pushContext(io.vertx.rxjava.ext.web.RoutingContext.class, io.vertx.rxjava.ext.web.RoutingContext.newInstance(routingContext.getDelegate())); resteasyHandler.handle(routingContext.request()); }); }).concatWith(doOnPlugins(plugin -> plugin.postRoute())) .concatWith(Completable.defer(() -> { // Start the front end server using the Jax-RS controller int port = globals.getConfig().getInteger("http_port", 9000); String host = globals.getConfig().getString("http_host", NetServerOptions.DEFAULT_HOST); return vertx.createHttpServer() .requestHandler(router::accept) .rxListen(port, host) .doOnSuccess(server -> System.out.println("Server started on port " + server.actualPort())) .doOnError(t -> t.printStackTrace()) .ignoreElement(); })); }); }
@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(); server.requestStream().toFlowable().subscribe(req -> { req.response().putHeader("content-type", "application/json").end(new JsonObject().put("time", System.currentTimeMillis()).toString()); }); server.listen(8080); } }
@Test public void testPost() { int times = 5; waitFor(times); HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080)); server.requestStream().handler(req -> req.bodyHandler(buff -> { assertEquals("onetwothree", buff.toString()); req.response().end(); })); try { server.listen(ar -> { client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions())); Observable<Buffer> stream = Observable.just(Buffer.buffer("one"), Buffer.buffer("two"), Buffer.buffer("three")); Single<HttpResponse<Buffer>> single = client .post(8080, "localhost", "/the_uri") .rxSendStream(stream); for (int i = 0; i < times; i++) { single.subscribe(resp -> complete(), this::fail); } }); await(); } finally { server.close(); } }
@Override public void start() { /** 1.Call router hub to mount commont **/ final Axis<Router> routerAxiser = Fn.poolThread(Pool.ROUTERS, () -> Ut.instance(RouterAxis.class)); /** 2.Call route hub to mount defined **/ final Axis<Router> axiser = Fn.poolThread(Pool.EVENTS, () -> Ut.instance(EventAxis.class)); /** 3.Get the default HttpServer Options **/ ZeroAtomic.RX_OPTS.forEach((port, option) -> { /** 3.1.Single server processing **/ final HttpServer server = this.vertx.createHttpServer(option); /** 3.2. Build router with current option **/ final Router router = Router.router(this.vertx); routerAxiser.mount(router); axiser.mount(router); /** 3.3. Listen for router on the server **/ final Single<HttpServer> result = server.requestHandler(router::accept).rxListen(); /** 3.4. Log output **/ { result.subscribe((rxServer) -> { this.recordServer(option, router); }); } }); }
@Override public void start() throws Exception { Router router = Router.router(vertx); router.route("/news-feed/*").handler(SockJSHandler.create(vertx).socketHandler(sockJSSocket -> { // Consumer the event bus address as an Flowable Flowable<String> msg = vertx.eventBus().<String>consumer("news-feed") .bodyStream() .toFlowable(); // Send the event to the client Disposable subscription = msg.subscribe(sockJSSocket::write); // Unsubscribe (dispose) when the socket closes sockJSSocket.endHandler(v -> { subscription.dispose(); }); })); // Serve the static resources router.route().handler(StaticHandler.create()); vertx.createHttpServer().requestHandler(router).listen(8080); // Publish a message to the address "news-feed" every second vertx.setPeriodic(1000, t -> vertx.eventBus().publish("news-feed", "news from the server!")); } }
@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(); server.requestStream().toFlowable().subscribe(req -> { req.response().putHeader("content-type", "application/json").end("{\"message\":\"Hello World\"}"); }); server.listen(8080); } }
@Test public void testResponseMissingBody() throws Exception { int times = 5; waitFor(times); HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080)); server.requestStream().handler(req -> req.response().setStatusCode(403).end()); try { server.listen(ar -> { client = WebClient.wrap(vertx.createHttpClient(new HttpClientOptions())); Single<HttpResponse<Buffer>> single = client .get(8080, "localhost", "/the_uri") .rxSend(); for (int i = 0; i < times; i++) { single.subscribe(resp -> { assertEquals(403, resp.statusCode()); assertNull(resp.body()); complete(); }, this::fail); } }); await(); } finally { server.close(); } }
server.requestStream().toFlowable() .doOnNext(request -> { HttpServerResponse response = request.response() .subscribe(); server.rxListen(config().getInteger("http.port", 8080)) .toCompletable() .subscribe(CompletableHelper.toObserver(future));
@Override public void start() { /** 1.Call router hub to mount commont **/ final Axis<Router> routerAxiser = Fn.poolThread(Pool.ROUTERS, () -> Ut.instance(RouterAxis.class)); /** 2.Call route hub to mount defined **/ final Axis<Router> axiser = Fn.poolThread(Pool.EVENTS, () -> Ut.instance(EventAxis.class)); /** 3.Get the default HttpServer Options **/ ZeroAtomic.RX_OPTS.forEach((port, option) -> { /** 3.1.Single server processing **/ final HttpServer server = this.vertx.createHttpServer(option); /** 3.2. Build router with current option **/ final Router router = Router.router(this.vertx); routerAxiser.mount(router); axiser.mount(router); /** 3.3. Listen for router on the server **/ final Single<HttpServer> result = server.requestHandler(router::accept).rxListen(); /** 3.4. Log output **/ { result.subscribe((rxServer) -> { this.recordServer(option, router); }); } }); }
@Override public void start(Future<Void> startFuture) { httpServer.requestHandler(request -> reactor.route().accept(request)); httpServer.listen(res -> { if (res.succeeded()) { logger.info("HTTP Server is now listening for requests on port {}", httpServerConfiguration.getPort()); startFuture.complete(); } else { logger.error("Unable to start HTTP Server", res.cause()); startFuture.fail(res.cause()); } }); }