@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()); }); }); } }
/** * 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, "")); }); }); }
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, "")); }); }); }
messages.forEach(msg -> msg.fail(throwableToCode(err), err.getMessage()));
public static <T>Message<T> newInstance(io.vertx.core.eventbus.Message arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T) { return arg != null ? new Message<T>(arg, __typeArg_T) : null; } }
/** * @return The message being delivered */ public io.vertx.rxjava.core.eventbus.Message<T> message() { io.vertx.rxjava.core.eventbus.Message<T> ret = io.vertx.rxjava.core.eventbus.Message.newInstance(delegate.message(), __typeArg_0); return ret; }
/** * 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 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(); }
.flatMap(msg -> { JsonObject body = msg.body(); String path = body.getString("path"); if (path == null) { msg.fail(400, "Missing path to the chunk to index"); return Observable.empty(); msg.fail(400, "Missing metadata for chunk " + path); return Observable.empty(); .map(doc -> Tuple.tuple(path, new JsonObject(doc), msg)) .onErrorResumeNext(err -> { msg.fail(throwableToCode(err), throwableToMessage(err, "")); return Observable.empty(); });
public static <T>Message<T> newInstance(io.vertx.core.eventbus.Message arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T) { return arg != null ? new Message<T>(arg, __typeArg_T) : null; } }
/** * @return The message being delivered */ public io.vertx.rxjava.core.eventbus.Message<T> message() { io.vertx.rxjava.core.eventbus.Message<T> ret = io.vertx.rxjava.core.eventbus.Message.newInstance(delegate.message(), __typeArg_0); return ret; }
/** * The same as <code>reply(R message, DeliveryOptions)</code> but you can specify handler for the reply - i.e. * to receive the reply to the reply. * @param message the reply message * @param options the delivery options * @return * @deprecated use {@link #rxReply} instead */ @Deprecated() public <R> Observable<io.vertx.rxjava.core.eventbus.Message<R>> replyObservable(Object message, DeliveryOptions options) { io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.eventbus.Message<R>> replyHandler = io.vertx.rx.java.RxHelper.observableFuture(); reply(message, options, replyHandler.toHandler()); return replyHandler; }
public static <T>Message<T> newInstance(io.vertx.core.eventbus.Message arg) { return arg != null ? new Message<T>(arg) : null; }
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)); }
/** * The same as <code>reply(R message)</code> but you can specify handler for the reply - i.e. * to receive the reply to the reply. * @param message the message to reply with. * @return * @deprecated use {@link #rxReply} instead */ @Deprecated() public <R> Observable<io.vertx.rxjava.core.eventbus.Message<R>> replyObservable(Object message) { io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.eventbus.Message<R>> replyHandler = io.vertx.rx.java.RxHelper.observableFuture(); reply(message, replyHandler.toHandler()); return replyHandler; }