@Override public synchronized MessageProducer<T> write(T data) { if (send) { doSend(data, null); } else { bus.publish(address, data, options); } return this; }
@Override public void start() throws Exception { EventBus eb = vertx.eventBus(); // Send a message every second vertx.setPeriodic(1000, v -> eb.publish("news-feed", "Some news!")); } }
@Override public void start() throws Exception { EventBus eb = vertx.eventBus(); // Send a message every second vertx.setPeriodic(1000, v -> eb.publish("news-feed", "Some news!")); } }
@Override public void start() throws Exception { EventBus eb = vertx.eventBus(); // Send a message every second vertx.setPeriodic(1000, v -> eb.publish("news-feed", "Some news!")); } }
private void threadB(AtomicInteger seq) { EventBus eventBus = vertx.eventBus(); MessageConsumer<Object> consumer = null; int count = 0; while (count < NUM_MSG) { while (count > seq.get()) { Thread.yield(); } count++; if (consumer != null) { consumer.unregister(); } consumer = eventBus.consumer(TEST_ADDR); consumer.handler(event -> { // Missing a message prevents the progression of the test seq.incrementAndGet(); }); // We use publish because send might deliver the message to a Thread-A's consumer // so we are sure we always get a message eventBus.publish(TEST_ADDR, count); } } }
private void testPauseResume(BiFunction<MessageConsumer<String>, Handler<String>, ReadStream<?>> register) { String[] data = new String[11]; for (int i = 0;i < data.length;i++) { data[i] = TestUtils.randomAlphaString(10); } Set<String> expected = new HashSet<>(); Handler<String> handler = body -> { assertTrue("Was expecting " + expected + " to contain " + body, expected.remove(body)); if (expected.isEmpty()) { testComplete(); } }; MessageConsumer<String> reg = eb.<String>consumer(ADDRESS1).setMaxBufferedMessages(10); ReadStream<?> controller = register.apply(reg, handler); ((HandlerRegistration<String>) reg).discardHandler(msg -> { assertEquals(data[10], msg.body()); expected.addAll(Arrays.asList(data).subList(0, 10)); controller.resume(); }); controller.pause(); for (String msg : data) { eb.publish(ADDRESS1, msg); } await(); }
@Test public void testContextsPublish() throws Exception { Set<ContextInternal> contexts = new ConcurrentHashSet<>(); AtomicInteger cnt = new AtomicInteger(); int numHandlers = 10; for (int i = 0; i < numHandlers; i++) { vertx.eventBus().consumer(ADDRESS1).handler(msg -> { contexts.add(((VertxInternal) vertx).getContext()); if (cnt.incrementAndGet() == numHandlers) { assertEquals(numHandlers, contexts.size()); testComplete(); } }); } vertx.eventBus().publish(ADDRESS1, "foo"); await(); }
@Override protected <T> void testPublish(T val, Consumer<T> consumer) { AtomicInteger count = new AtomicInteger(); class MyHandler implements Handler<Message<T>> { @Override public void handle(Message<T> msg) { if (consumer == null) { assertFalse(msg.isSend()); assertEquals(val, msg.body()); } else { consumer.accept(msg.body()); } if (count.incrementAndGet() == 2) { testComplete(); } } } eb.<T>consumer(ADDRESS1).handler(new MyHandler()); eb.<T>consumer(ADDRESS1).handler(new MyHandler()); eb.publish(ADDRESS1, val); await(); }
@Test public void testFailAfterSend() { eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { msg.fail(0, "a failure"); testComplete(); }); eb.publish(ADDRESS1, "whatever"); await(); }
@Test public void testReplyToPublish() { eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { msg.reply("a reply"); testComplete(); }); eb.publish(ADDRESS1, "whatever"); await(); }
@Test public void testFailAfterPublish() { eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { msg.fail(0, "a failure"); testComplete(); }); eb.publish(ADDRESS1, "whatever"); await(); }
@Test public void testPublishSameHandlerRegisteredTwice() { String str = TestUtils.randomUnicodeString(1000); AtomicInteger count = new AtomicInteger(); Handler<Message<String>> handler = (Message<String> msg) -> { assertEquals(str, msg.body()); if (count.incrementAndGet() == 2) { testComplete(); } }; eb.<String>consumer(ADDRESS1).handler(handler); eb.<String>consumer(ADDRESS1).handler(handler); eb.publish(ADDRESS1, str); await(); }
private void testReceiveMessagePublished(Vertx from, Vertx to, boolean expectedLocal, int expectedHandlers) { FakeEventBusMetrics eventBusMetrics = FakeMetricsBase.getMetrics(to.eventBus()); AtomicInteger count = new AtomicInteger(); for (int i = 0; i < expectedHandlers; i++) { MessageConsumer<Object> consumer = to.eventBus().consumer(ADDRESS1); consumer.completionHandler(done -> { assertTrue(done.succeeded()); if (count.incrementAndGet() == expectedHandlers) { String msg = TestUtils.randomAlphaString(10); from.eventBus().publish(ADDRESS1, msg); } }); int index = i; consumer.handler(msg -> { if (index == 0) { assertEquals(Arrays.asList(new ReceivedMessage(ADDRESS1, true, expectedLocal, expectedHandlers)), eventBusMetrics.getReceivedMessages()); testComplete(); } }); } await(); }
@Test public void testPublishMultipleHandlers() { String str = TestUtils.randomUnicodeString(100); AtomicInteger count = new AtomicInteger(); eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { assertEquals(str, msg.body()); if (count.incrementAndGet() == 2) { testComplete(); } }); eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { assertEquals(str, msg.body()); if (count.incrementAndGet() == 2) { testComplete(); } }); eb.publish(ADDRESS1, str); await(); }
@Test public void testPublish() { String str = TestUtils.randomUnicodeString(100); eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { assertEquals(str, msg.body()); testComplete(); }); eb.publish(ADDRESS1, str); await(); }
private void testDeliveryOptionsLocalOnly(boolean send) { waitFor(30); startNodes(2); AtomicLong localConsumer0 = new AtomicLong(); vertices[0].eventBus().localConsumer(ADDRESS1).handler(msg -> { localConsumer0.incrementAndGet(); complete(); }); AtomicLong consumer1 = new AtomicLong(); vertices[1].eventBus().consumer(ADDRESS1).handler(msg -> { consumer1.incrementAndGet(); }).completionHandler(onSuccess(v -> { for (int i = 0; i < 30; i++) { if (send) { vertices[0].eventBus().send(ADDRESS1, "msg", new DeliveryOptions().setLocalOnly(true)); } else { vertices[0].eventBus().publish(ADDRESS1, "msg", new DeliveryOptions().setLocalOnly(true)); } } })); await(); assertEquals(30, localConsumer0.get()); assertEquals(0, consumer1.get()); }
@Test public void testPublishMultipleHandlersDifferentAddresses() { String str = TestUtils.randomUnicodeString(1000); eb.<String>consumer(ADDRESS1).handler((Message<String> msg) -> { assertEquals(str, msg.body()); testComplete(); }); eb.<String>consumer(ADDRESS2).handler((Message<String> msg) -> { fail("Should not receive message"); }); eb.publish(ADDRESS1, str); await(); }
@Test public void testPublishMultipleHandlersUnregisterOne() { String str = TestUtils.randomUnicodeString(1000); Handler<Message<String>> handler1 = (Message<String> msg) -> { assertEquals(str, msg.body()); testComplete(); }; Handler<Message<String>> handler2 = (Message<String> msg) -> { fail("Should not be called"); }; eb.<String>consumer(ADDRESS1).handler(handler1); MessageConsumer reg = eb.<String>consumer(ADDRESS1).handler(handler2); reg.unregister(); eb.publish(ADDRESS1, str); await(); }
@Test public void testOutboundInterceptorOnPublish() { eb.addOutboundInterceptor(sc -> { assertEquals("armadillo", sc.message().body()); assertFalse(sc.send()); sc.next(); }); eb.consumer("some-address", msg -> { assertEquals("armadillo", msg.body()); testComplete(); }); eb.publish("some-address", "armadillo"); await(); }
@Test public void testInterceptorsOnPublish() { eb.addOutboundInterceptor(sc -> { assertEquals("armadillo", sc.message().body()); assertFalse(sc.send()); sc.next(); }).addInboundInterceptor(dc -> { assertEquals("armadillo", dc.message().body()); assertFalse(dc.send()); dc.next(); }); eb.consumer("some-address", msg -> { assertEquals("armadillo", msg.body()); testComplete(); }); eb.publish("some-address", "armadillo"); await(); }