/** * Takes the event bus off the provided vert.x instance * * @param vertx the vertx instance with the event bus to wrap * @param container the container instance */ @Inject public DefaultWhenEventBus(Vertx vertx, Container container, When when) { this(vertx.eventBus(), when); }
/** * Returns the Vert.x event bus. */ public static EventBus eventBus(Env env) { return new EventBus(PhpVerticleFactory.vertx.eventBus()); }
public void register(final String testName, final Handler<Void> handler) { Handler<Message<JsonObject>> h = new Handler<Message<JsonObject>>() { public void handle(Message<JsonObject> msg) { if (EventFields.START_TEST_EVENT.equals(msg.body().getString(EventFields.TYPE_FIELD)) && testName.equals(msg.body().getString(EventFields.START_TEST_NAME_FIELD))) { handler.handle(null); } } }; vertx.eventBus().registerHandler(TestBase.EVENTS_ADDRESS, h); handlers.put(testName, h); }
protected SockJSSocket(Vertx vertx) { this.vertx = vertx; this.writeHandler = new Handler<Message<Buffer>>() { public void handle(Message<Buffer> buff) { writeBuffer(buff.body); } }; this.writeHandlerID = UUID.randomUUID().toString(); vertx.eventBus().registerLocalHandler(writeHandlerID, writeHandler); cnt.incrementAndGet(); }
public void unregisterAll() { for (Handler<Message<JsonObject>> handler: handlers.values()) { vertx.eventBus().unregisterHandler(TestBase.EVENTS_ADDRESS, handler); } handlers.clear(); }
public void close() { vertx.eventBus().unregisterHandler(writeHandlerID, writeHandler); }
public EventBusBridge(Vertx vertx, JsonArray inboundPermitted, JsonArray outboundPermitted, long authTimeout, String authAddress) { this.vertx = vertx; this.eb = vertx.eventBus(); this.inboundPermitted = convertArray(inboundPermitted); this.outboundPermitted = convertArray(outboundPermitted); if (authTimeout < 0) { throw new IllegalArgumentException("authTimeout < 0"); } this.authTimeout = authTimeout; if (authAddress == null) { authAddress = DEFAULT_AUTH_ADDRESS; } this.authAddress = authAddress; }
/** * Start the busmod */ public void start() { eb = vertx.eventBus(); config = container.config(); logger = container.logger(); }
/** * Start the busmod */ public void start() { eb = vertx.eventBus(); config = container.getConfig(); logger = container.getLogger(); }
/** Create RxVertx from Core */ public RxVertx(Vertx vertx) { this.core=vertx; this.eventBus=new RxEventBus(core.eventBus()); this.timer=new RxTimer(core); }
public static void handleThrowable(Throwable t) { if (jVertx == null) { throw new IllegalStateException("Please initialise VertxAssert before use"); } // Serialize the error JsonObject failure = new JsonObject().putString("type", "failure"); byte[] bytes; try { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(t); oos.flush(); bytes = baos.toByteArray(); failure.putBinary("failure", bytes); } catch (IOException ex) { throw new IllegalStateException("Failed to serialise error: " + ex.getMessage(), ex); } finally { jVertx.eventBus().send(JavaClassRunner.TESTRUNNER_HANDLER_ADDRESS, failure); } }
public static void testComplete() { jVertx.eventBus().send(JavaClassRunner.TESTRUNNER_HANDLER_ADDRESS, new JsonObject().putString("type", "done")); }
private void sendMessage(JsonObject msg) { EventLog.addEvent("Sending message: " + msg.encode()); try { vertx.eventBus().publish(TestBase.EVENTS_ADDRESS, msg); } catch (Exception e) { log.error("Failed to send message", e); } }
/** * Deploys a deployment. */ private void doClusterDeploy(final Message<JsonObject> message) { String group = message.body().getString("group"); if (group == null) { doInternalDeploy(message); } else { vertx.eventBus().sendWithTimeout(String.format("%s.%s", cluster, group), message.body(), 30000, new Handler<AsyncResult<Message<JsonObject>>>() { @Override public void handle(AsyncResult<Message<JsonObject>> result) { if (result.failed()) { message.reply(new JsonObject().putString("status", "error").putString("message", result.cause().getMessage())); } else { message.reply(result.result().body()); } } }); } }
@Override protected void tearDown() throws Exception { try { throwAsserts(); } finally { try { List<String> apps = new ArrayList<>(startedApps); for (String appName: apps) { stopApp(appName); } events.clear(); vertx.eventBus().unregisterHandler(EVENTS_ADDRESS, handler); } catch (Exception e) { e.printStackTrace(); throw e; } } if (platformManager.checkNoModules() > 0) { fail("Module references remain after test"); } EventLog.addEvent("teardown complete"); EventLog.clear(); }
@Override public void start() throws Exception { if (this.isStarted) { return; } System.setProperty("vertx.clusterManagerFactory", HazelcastClusterManagerFactory.class.getName()); if (quorumSize != -1) { platformManager = PlatformLocator.factory.createPlatformManager(port, host, quorumSize, haGroup); } else { platformManager = PlatformLocator.factory.createPlatformManager(port, host); } eventBus = platformManager.vertx().eventBus(); Binding b = postOffice.getBinding(new SimpleString(queueName)); if (b == null) { throw new Exception(connectorName + ": queue " + queueName + " not found"); } handler = new EventHandler(); eventBus.registerHandler(vertxAddress, handler); isStarted = true; ActiveMQVertxLogger.LOGGER.debug(connectorName + ": started"); }
/** * Sends the given event to the emulator, with the given additional parameters * * @param outputEventType The event to send * @param params The additional parameters */ private void publishEvent(OutputEventType outputEventType, JsonObject params) { JsonObject payload = new JsonObject(); payload.putString("evt", outputEventType.name()); if (params != null) { payload.mergeIn(params); } vertx.eventBus().publish(EVENTBUS_CLIENT_HANDLER_ID, payload); }
@Override public void handle(AsyncResult<String> result) { if (result.failed()) { message.reply(new JsonObject().putString("status", "error").putString("message", result.cause().getMessage())); } else { vertx.eventBus().sendWithTimeout(result.result(), message.body(), 30000, new Handler<AsyncResult<Message<JsonObject>>>() { @Override public void handle(AsyncResult<Message<JsonObject>> result) { if (result.failed()) { message.reply(new JsonObject().putString("status", "error").putString("message", result.cause().getMessage())); } else { message.reply(result.result().body()); } } }); } } });
@Override public void start() { super.start(); topic = getOptionalStringConfig(KAFKA_TOPIC, DEFAULT_TOPIC); serializerType = MessageSerializerType.getEnum(getOptionalStringConfig(SERIALIZER_CLASS, MessageSerializerType.BYTE_SERIALIZER.toString())); producer = createProducer(); statsDClient = createStatsDClient(); // Get the address of EventBus where the message was published final String address = getMandatoryStringConfig("address"); vertx.eventBus().registerHandler(address, this); }
/** * Constructor. * * @param httpPort The HTTP port on which the emulator should run. */ public EmulatorLaunchpad(int httpPort) { vertx = VertxFactory.newVertx(); // Static files HttpServer httpServer = vertx.createHttpServer(); httpServer.requestHandler(new WebResourceHandler()); // Eventbus bridge JsonObject bridgeConfig = new JsonObject().putString("prefix", EVENTBUS_ADDRESS); JsonArray credentialsPermitAll = new JsonArray().add(new JsonObject()); vertx.createSockJSServer(httpServer).bridge(bridgeConfig, credentialsPermitAll, credentialsPermitAll); vertx.eventBus().registerLocalHandler(EVENTBUS_SERVER_HANDLER_ID, eventBusHandler); System.out.println("Launchpad emulator is ready on http://localhost:" + httpPort + "/"); httpServer.listen(httpPort); }