@Override public void start() throws Exception { EventBus eb = vertx.eventBus(); eb.consumer("news-feed"). toObservable(). subscribe(message -> System.out.println("Received news: " + message.body())); System.out.println("Ready!"); } }
@Override public void start() throws Exception { Random random1 = new Random(); EventBus eb = vertx.eventBus(); eb.consumer("heatsensor1"). toObservable(). subscribe(message -> { message.reply(9 + random1.nextInt(5)); }); eb.consumer("heatsensor2"). toObservable(). subscribe(message -> { message.reply(10 + random1.nextInt(3)); }); } }
@Override public void start() throws Exception { EventBus eb = vertx.eventBus(); eb.consumer(ADDRESS) .toObservable() .subscribe(message -> { System.out.println("Received " + message.body()); message.reply("PONG"); }); // Send a message every second vertx.setPeriodic(1000, v -> { eb.rxSend(ADDRESS, "PING") .subscribe(reply -> { System.out.println("Received reply " + reply.body()); }); }); } }
@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 Observable Observable<String> msg = vertx.eventBus().<String>consumer("news-feed") .bodyStream() .toObservable(); // Send the event to the client Subscription subscription = msg.subscribe(sockJSSocket::write); // Unsubscribe when the socket closes sockJSSocket.endHandler(v -> { subscription.unsubscribe(); }); })); // 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!")); } }
private void registerConsumer(final String dbname) { LOG.debug("Registering handler for {} database", dbname); if(LOG.isTraceEnabled()){ vertx.eventBus().<JsonObject>consumer("/store/" + dbname, msg -> { LOG.trace("received datapoint for db '{}': {}", dbname, msg.body()); }); } vertx.eventBus().<JsonObject>consumer("/store/" + dbname).bodyStream() .toObservable() .buffer(config().getInteger("maxRowLimit", 1000)) .map(this::joinDataPoints) .subscribe(result -> sendDatapoint(dbname, result)); vertx.eventBus().<JsonObject>consumer("/influx/write?db=" + dbname).bodyStream() .toObservable() .buffer(config().getInteger("maxRowLimit", 1000)) .map(this::joinDataPoints) .subscribe(result -> sendDatapoint(dbname, result)); }
private <T> void register(String address, Function<JsonObject, Single<T>> mapper) { vertx.eventBus().<JsonObject>consumer(address) .toObservable() .subscribe(msg -> { mapper.apply(msg.body()).subscribe(msg::reply, err -> { log.error("Could not perform query", err); msg.fail(throwableToCode(err), throwableToMessage(err, "")); }); }); }
@Override public void start() throws Exception { vertx.eventBus().consumer("check", message -> message.reply("Check!")); } }
indexerQuerySubscription = vertx.eventBus().<JsonObject>consumer(AddressConstants.INDEXER_QUERY).toObservable() .subscribe(msg -> { JsonArray hits = new JsonArray();
/** * Register consumer for delete messages */ private void registerDelete() { vertx.eventBus().<JsonObject>consumer(AddressConstants.INDEXER_DELETE) .toObservable() .subscribe(msg -> { onDelete(msg.body()).subscribe(() -> { msg.reply(null); }, err -> { log.error("Could not delete document", err); msg.fail(throwableToCode(err), throwableToMessage(err, "")); }); }); }
/** * Register consumer for queries */ private void registerQuery() { vertx.eventBus().<JsonObject>consumer(AddressConstants.INDEXER_QUERY) .toObservable() .subscribe(msg -> { onQuery(msg.body()).subscribe(reply -> { msg.reply(reply); }, err -> { log.error("Could not perform query", err); msg.fail(throwableToCode(err), throwableToMessage(err, "")); }); }); }
@Test public void testUnregisterConsumer() { EventBus eb = vertx.eventBus(); MessageConsumer<String> consumer = eb.<String>consumer("the-address"); Observable<String> obs = consumer.bodyStream().toObservable(); obs.subscribe(new Subscriber<String>() { @Override public void onCompleted() { testComplete(); } @Override public void onError(Throwable e) { fail(e.getMessage()); } @Override public void onNext(String str) { fail(); } }); consumer.unregister(); await(); }
@Test public void testObservableUnsubscribeDuringObservation() { EventBus eb = vertx.eventBus(); MessageConsumer<String> consumer = eb.<String>consumer("the-address"); Observable<String> obs = consumer.bodyStream().toObservable(); Observable<String> a = obs.take(4); List<String> obtained = new ArrayList<>(); a.subscribe(new Subscriber<String>() { @Override public void onCompleted() { assertEquals(Arrays.asList("msg0", "msg1", "msg2", "msg3"), obtained); testComplete(); } @Override public void onError(Throwable e) { fail(e.getMessage()); } @Override public void onNext(String str) { obtained.add(str); } }); for (int i = 0; i < 7; i++) { eb.send("the-address", "msg" + i); } await(); }
vertx.eventBus().<JsonObject>consumer(AddressConstants.INDEXER_ADD) .toObservable() .doOnNext(v -> {
@Test public void testConcatReplies() { EventBus eb = vertx.eventBus(); eb.<String>consumer("the-address", msg -> { msg.reply(msg.body()); }); Single<Message<String>> obs1 = eb.rxSend("the-address", "msg1"); Single<Message<String>> obs2 = eb.rxSend("the-address", "msg2"); eb.send("the-address", "done", reply -> { Observable<Message<String>> all = Single.concat(obs1, obs2); LinkedList<String> values = new LinkedList<String>(); all.subscribe(next -> { values.add(next.body()); }, err -> { fail(); }, () -> { assertEquals(Arrays.asList("msg1", "msg2"), values); testComplete(); }); }); await(); }
@Test public void testConsumeBodyStream() { EventBus eb = vertx.eventBus(); MessageConsumer<String> consumer = eb.<String>consumer("the-address"); Observable<String> obs = consumer.bodyStream().toObservable(); List<String> items = new ArrayList<>();
eb.consumer("http-ref", message -> discovery.getRecord(rec -> rec.getName().equalsIgnoreCase("my-http-service"), ar -> { if (ar.failed()) { eb.consumer("http-sugar", message -> { JsonObject result = new JsonObject(); HttpEndpoint.getClient(discovery, record -> record.getName().equalsIgnoreCase("my-http-service"), eb.consumer("web-ref", message -> discovery.getRecord(rec -> rec.getName().equalsIgnoreCase("my-http-service"), ar -> { if (ar.failed()) { eb.consumer("web-sugar", message -> { JsonObject result = new JsonObject(); HttpEndpoint.getWebClient(discovery, record -> record.getName().equalsIgnoreCase("my-http-service"), eb.consumer("service-ref", message -> discovery.getRecord(rec -> rec.getName().equalsIgnoreCase("my-service"), ar -> { if (ar.failed()) { eb.consumer("service-sugar", message -> { JsonObject result = new JsonObject(); EventBusService.getServiceProxy(discovery, eb.consumer("ds-ref", message -> discovery.getRecord(rec -> rec.getName().equalsIgnoreCase("my-data-source"), ar -> { if (ar.failed()) { eb.consumer("ds-sugar", message -> {
@Test public void testRegisterAgain() { EventBus eb = vertx.eventBus(); MessageConsumer<String> consumer = eb.<String>consumer("the-address"); Observable<String> obs = consumer.bodyStream().toObservable(); obs.subscribe(new Subscriber<String>() {
vertx.eventBus().consumer("a", h -> { context.assertEquals(data, h.body()); aC.complete(); }); vertx.eventBus().consumer("a", h -> { context.assertEquals(data, h.body()); bC.complete(); }); vertx.eventBus().consumer("b", h -> { context.assertEquals(data, h.body()); cC.complete(); }); vertx.eventBus().consumer("b", h -> { context.assertEquals(data, h.body()); dC.complete();
/** * Test if a message can be sent and if a consumer receives the message. * This method does not test if the message can be sent to only one * consumer (instead of all, see {@link #broadcast(TestContext)}), * because it's not possible to check if a consumer will not receive a * message before the asynchronous test ends. * @param context the test context */ @Test public void send(TestContext context) { Vertx vertx = new Vertx(rule.vertx()); Async a = context.async(); String data = "special data"; vertx.eventBus().consumer("a", h -> { context.assertEquals(data, h.body()); a.complete(); }); ServiceDiscovery discovery = ServiceDiscovery.create(vertx); Service.publishOnce("A", "a", discovery, vertx) .andThen(Service.discover("A", discovery, vertx)) .doOnTerminate(discovery::close) .subscribe(service -> { service.broadcast(data); service.send(data); }, context::fail); }