@Test public void testSimpleFailover() throws Exception { startNodes(2, new VertxOptions().setHAEnabled(true)); DeploymentOptions options = new DeploymentOptions().setHa(true); JsonObject config = new JsonObject().put("foo", "bar"); options.setConfig(config); CountDownLatch latch = new CountDownLatch(1); vertices[0].deployVerticle("java:" + HAVerticle1.class.getName(), options, ar -> { assertTrue(ar.succeeded()); assertEquals(1, vertices[0].deploymentIDs().size()); assertEquals(0, vertices[1].deploymentIDs().size()); latch.countDown(); }); awaitLatch(latch); kill(0); assertWaitUntil(() -> vertices[1].deploymentIDs().size() == 1); checkDeploymentExists(1, "java:" + HAVerticle1.class.getName(), options); }
vertx.deployVerticle("io.vertx.example.core.verticle.deploy.OtherVerticle"); vertx.deployVerticle("io.vertx.example.core.verticle.deploy.OtherVerticle", res -> { if (res.succeeded()) { String deploymentID = res.result(); vertx.undeploy(deploymentID, res2 -> { if (res2.succeeded()) { System.out.println("Undeployed ok!"); } else { JsonObject config = new JsonObject().put("foo", "bar"); vertx.deployVerticle("io.vertx.example.core.verticle.deploy.OtherVerticle", new DeploymentOptions().setConfig(config)); vertx.deployVerticle("io.vertx.example.core.verticle.deploy.OtherVerticle", new DeploymentOptions().setInstances(10)); vertx.deployVerticle("io.vertx.example.core.verticle.deploy.OtherVerticle", new DeploymentOptions().setWorker(true));
@Override public void start() throws Exception { vertx.deployVerticle( "io.vertx.example.core.http.sharing.HttpServerVerticle", new DeploymentOptions().setInstances(2)); } }
public static void main(String[] args) { Vertx vertx = Vertx.vertx(); ApplicationContext context = new AnnotationConfigApplicationContext(ExampleApplication.class); VerticleFactory verticleFactory = context.getBean(SpringVerticleFactory.class); // The verticle factory is registered manually because it is created by the Spring container vertx.registerVerticleFactory(verticleFactory); // Scale the verticles on cores: create 4 instances during the deployment DeploymentOptions options = new DeploymentOptions().setInstances(4); vertx.deployVerticle(verticleFactory.prefix() + ":" + GreetingVerticle.class.getName(), options); }
@Override public void start(Future<Void> startFuture) throws Exception { JsonObject options = new JsonObject().put("telnetOptions", new JsonObject(). put("host", "localhost"). put("port", 3000) ); vertx.deployVerticle("service:io.vertx.ext.shell", new DeploymentOptions().setConfig(options), ar -> { if (ar.succeeded()) { startFuture.succeeded(); } else { startFuture.fail(ar.cause()); } }); } }
@Test public void testNonHADeployments() throws Exception { vertx1 = startVertx(); vertx2 = startVertx(); // Deploy an HA and a non HA deployment CountDownLatch latch1 = new CountDownLatch(2); vertx2.deployVerticle("java:" + HAVerticle1.class.getName(), new DeploymentOptions().setHa(true), ar -> { assertTrue(ar.succeeded()); assertTrue(vertx2.deploymentIDs().contains(ar.result())); latch1.countDown(); }); vertx2.deployVerticle("java:" + HAVerticle2.class.getName(), new DeploymentOptions().setHa(false), ar -> { assertTrue(ar.succeeded()); assertTrue(vertx2.deploymentIDs().contains(ar.result())); latch1.countDown(); }); awaitLatch(latch1); CountDownLatch latch2 = new CountDownLatch(1); ((VertxInternal)vertx1).failoverCompleteHandler((nodeID, haInfo, succeeded) -> { assertTrue(succeeded); latch2.countDown(); }); ((VertxInternal)vertx2).simulateKill(); awaitLatch(latch2); assertTrue(vertx1.deploymentIDs().size() == 1); String depID = vertx1.deploymentIDs().iterator().next(); assertTrue(((VertxInternal) vertx1).getDeployment(depID).verticleIdentifier().equals("java:" + HAVerticle1.class.getName())); }
@Test public void testGetInstanceCountMultipleVerticles() throws Exception { AtomicInteger messageCount = new AtomicInteger(0); AtomicInteger totalReportedInstances = new AtomicInteger(0); vertx.eventBus().consumer("instanceCount", event -> { messageCount.incrementAndGet(); totalReportedInstances.addAndGet((int)event.body()); if(messageCount.intValue() == 3) { assertEquals(9, totalReportedInstances.get()); testComplete(); } }); vertx.deployVerticle(TestVerticle3.class.getCanonicalName(), new DeploymentOptions().setInstances(3), ar -> { assertTrue(ar.succeeded()); }); await(); Deployment deployment = ((VertxInternal) vertx).getDeployment(vertx.deploymentIDs().iterator().next()); CountDownLatch latch = new CountDownLatch(1); vertx.undeploy(deployment.deploymentID(), ar -> latch.countDown()); awaitLatch(latch); }
final String verticleName = failedVerticle.getString("verticle_name"); final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<Throwable> err = new AtomicReference<>(); ContextInternal ctx = vertx.getContext(); if (ctx != null) { JsonObject options = failedVerticle.getJsonObject("options"); try { doDeployVerticle(verticleName, new DeploymentOptions(options), result -> { if (result.succeeded()) { log.info("Successfully redeployed verticle " + verticleName + " after failover"); } else { log.error("Failed to redeploy verticle after failover", result.cause()); err.set(result.cause()); latch.countDown(); Throwable t = err.get(); if (t != null) { if (!latch.await(120, TimeUnit.SECONDS)) { throw new VertxException("Timed out waiting for redeploy on failover");
@Test public void testCleanCloseNoFailover() throws Exception { vertx1 = startVertx(); vertx2 = startVertx(); DeploymentOptions options = new DeploymentOptions().setHa(true); JsonObject config = new JsonObject().put("foo", "bar"); options.setConfig(config); CountDownLatch deployLatch = new CountDownLatch(1); vertx2.deployVerticle("java:" + HAVerticle1.class.getName(), options, ar -> { assertTrue(ar.succeeded()); deployLatch.countDown(); }); awaitLatch(deployLatch); ((VertxInternal)vertx1).failoverCompleteHandler((nodeID, haInfo, succeeded) -> { fail("Should not be called"); }); vertx2.close(ar -> { vertx.setTimer(500, tid -> { // Wait a bit in case failover happens testComplete(); }); }); await(); }
private void testIsolationGroup(String group1, String group2, int count1, int count2, List<String> isolatedClasses, String verticleID) throws Exception { Map<String, Integer> countMap = new ConcurrentHashMap<>(); vertx.eventBus().<JsonObject>consumer("testcounts").handler((Message<JsonObject> msg) -> { countMap.put(msg.body().getString("deploymentID"), msg.body().getInteger("count")); }); CountDownLatch latch = new CountDownLatch(1); AtomicReference<String> deploymentID1 = new AtomicReference<>(); AtomicReference<String> deploymentID2 = new AtomicReference<>(); boolean expectedSuccess = Thread.currentThread().getContextClassLoader() instanceof URLClassLoader; try { vertx.deployVerticle(verticleID, new DeploymentOptions(). setIsolationGroup(group1).setIsolatedClasses(isolatedClasses), ar -> { assertTrue(ar.succeeded()); deploymentID1.set(ar.result()); assertEquals(0, TestVerticle.instanceCount.get()); vertx.deployVerticle(verticleID, new DeploymentOptions().setIsolationGroup(group2).setIsolatedClasses(isolatedClasses), ar2 -> { assertTrue(ar2.succeeded()); deploymentID2.set(ar2.result()); assertEquals(0, TestVerticle.instanceCount.get()); latch.countDown(); }); });
vertx2 = startVertx("group2", 2); vertx1.deployVerticle("java:" + HAVerticle1.class.getName(), new DeploymentOptions().setHa(true), ar -> { assertTrue(ar.succeeded()); assertTrue(vertx1.deploymentIDs().contains(ar.result())); }); assertTrue(vertx1.deploymentIDs().isEmpty()); assertWaitUntil(() -> vertx1.deploymentIDs().size() == 1); vertx2.deployVerticle("java:" + HAVerticle1.class.getName(), new DeploymentOptions().setHa(true), ar -> { assertTrue(ar.succeeded()); assertTrue(vertx2.deploymentIDs().contains(ar.result())); }); CountDownLatch latch = new CountDownLatch(1); vertx4.close(ar -> { latch.countDown(); }); assertTrue(vertx1.deploymentIDs().size() == 1); CountDownLatch latch2 = new CountDownLatch(1); vertx3.close(ar -> { latch2.countDown();
private void testVerticleUseDifferentOrderedExecutor(boolean worker) throws Exception { waitFor(2); CountDownLatch latch1 = new CountDownLatch(1); CountDownLatch latch2 = new CountDownLatch(1); vertx.deployVerticle(new AbstractVerticle() { @Override public void start() throws Exception { }); }, new DeploymentOptions().setWorker(worker)); awaitLatch(latch1); CountDownLatch latch3 = new CountDownLatch(1); vertx.deployVerticle(new AbstractVerticle() { @Override public void start() throws Exception { }); }, new DeploymentOptions().setWorker(worker)); awaitLatch(latch3); latch2.countDown();
@Test public void testReplyFromWorker() throws Exception { String expectedBody = TestUtils.randomAlphaString(20); startNodes(2); CountDownLatch latch = new CountDownLatch(1); vertices[0].deployVerticle(new AbstractVerticle() { @Override public void start() throws Exception { vertices[1].eventBus().<String>consumer(ADDRESS1, msg -> { msg.reply(expectedBody); }).completionHandler(ar -> { assertTrue(ar.succeeded()); latch.countDown(); }); } }, new DeploymentOptions().setWorker(true)); awaitLatch(latch); vertices[0].eventBus().send(ADDRESS1, "whatever", reply -> { assertTrue(reply.succeeded()); assertEquals(expectedBody, reply.result().body()); testComplete(); }); await(); }
@Test public void testWorkerExecuteFromIo() throws Exception { AtomicReference<ContextInternal> workerContext = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); vertx.deployVerticle(new AbstractVerticle() { @Override public void start() throws Exception { workerContext.set((ContextInternal) context); latch.countDown(); } }, new DeploymentOptions().setWorker(true)); awaitLatch(latch); workerContext.get().nettyEventLoop().execute(() -> { assertNull(Vertx.currentContext()); workerContext.get().nettyEventLoop().execute(() -> { workerContext.get().executeFromIO(v -> { assertSame(workerContext.get(), Vertx.currentContext()); assertTrue(Context.isOnWorkerThread()); testComplete(); }); }); }); await(); }
vertx.registerVerticleFactory(fact); TestVerticleFactory factResolve = new TestVerticleFactory("resolve", "actual:myverticle", "othergroup"); vertx.registerVerticleFactory(factResolve); JsonObject config = new JsonObject().put("foo", "bar"); DeploymentOptions original = new DeploymentOptions().setWorker(false).setConfig(config).setIsolationGroup("somegroup"); DeploymentOptions options = new DeploymentOptions(original); vertx.deployVerticle("resolve:someid", options, res -> { assertTrue(res.succeeded()); assertEquals("resolve:someid", factResolve.identifierToResolve); assertEquals(options, factResolve.deploymentOptionsToResolve); assertTrue(verticle.startCalled); assertEquals(1, vertx.deploymentIDs().size()); Deployment dep = ((VertxInternal)vertx).getDeployment(res.result()); assertNotNull(dep); assertFalse(original.equals(dep.deploymentOptions())); assertFalse(dep.deploymentOptions().getConfig().containsKey("foo")); assertEquals("quux", dep.deploymentOptions().getConfig().getString("wibble")); assertTrue(dep.deploymentOptions().isWorker()); assertEquals("othergroup", dep.deploymentOptions().getIsolationGroup()); testComplete(); });
@Test public void testQuorum() throws Exception { vertx1 = startVertx(2); DeploymentOptions options = new DeploymentOptions().setHa(true); JsonObject config = new JsonObject().put("foo", "bar"); options.setConfig(config); vertx1.deployVerticle("java:" + HAVerticle1.class.getName(), options, ar -> { assertTrue(ar.succeeded()); assertTrue(vertx1.deploymentIDs().contains(ar.result())); testComplete(); }); // Shouldn't deploy until a quorum is obtained assertWaitUntil(() -> vertx1.deploymentIDs().isEmpty()); vertx2 = startVertx(2); // Now should be deployed await(); }
@Override public void start(Future<Void> startFuture) throws Exception { vertx.deployVerticle("java:" + OtherSourceVerticle.class.getName().replace('.', '/') + ".java", new DeploymentOptions(), ar -> { if (ar.succeeded()) { startFuture.complete((Void) null); } else { ar.cause().printStackTrace(); } }); } }
@Test public void testToJson() { DeploymentOptions options = new DeploymentOptions(); JsonObject config = new JsonObject().put("foo", "bar"); Random rand = new Random(); boolean worker = rand.nextBoolean(); long maxWorkerExecuteTime = TestUtils.randomPositiveLong(); TimeUnit maxWorkerExecuteTimeUnit = TimeUnit.MILLISECONDS; options.setConfig(config); options.setWorker(worker); options.setIsolationGroup(isolationGroup); options.setHa(ha); options.setExtraClasspath(cp); options.setIsolatedClasses(isol); options.setWorkerPoolName(poolName); options.setWorkerPoolSize(poolSize); options.setMaxWorkerExecuteTime(maxWorkerExecuteTime); options.setMaxWorkerExecuteTimeUnit(maxWorkerExecuteTimeUnit); JsonObject json = options.toJson(); DeploymentOptions copy = new DeploymentOptions(json); assertEquals(worker, copy.isWorker()); assertEquals(isolationGroup, copy.getIsolationGroup()); assertEquals("bar", copy.getConfig().getString("foo")); assertEquals(ha, copy.isHa()); assertEquals(cp, copy.getExtraClasspath()); assertEquals(isol, copy.getIsolatedClasses()); assertEquals(poolName, copy.getWorkerPoolName()); assertEquals(poolSize, copy.getWorkerPoolSize()); assertEquals(maxWorkerExecuteTime, copy.getMaxWorkerExecuteTime());
@Test public void testDeployWorkerFromTestThread() throws Exception { MyVerticle verticle = new MyVerticle(); vertx.deployVerticle(verticle, new DeploymentOptions().setWorker(true), ar -> { assertDeployment(1, verticle, null, ar); assertTrue(verticle.startContext.isWorkerContext()); vertx.undeploy(ar.result(), ar2 -> { assertTrue(ar2.succeeded()); assertEquals(verticle.startContext, verticle.stopContext); testComplete(); }); }); await(); }
/** * Deploy verticles when the Spring application is ready. */ @EventListener void deployVerticles(ApplicationReadyEvent event) { vertx.deployVerticle(new HelloVerticle()); if (port != null) { JsonObject config = new JsonObject().put("port", port); vertx.deployVerticle(new HttpVerticle(), new DeploymentOptions().setConfig(config)); } } }