public SomeClusterSerializableObject(String str) { this.str = str; vertx = Vertx.vertx(); }
public SomeClusterSerializableObject() { vertx = Vertx.vertx(); }
public static void main(String[] args) { Vertx.vertx().deployVerticle(new MainVerticle()); }
/** * Creates a new non-clustered vert.x instance. * * @param options the options * @return the created instance */ protected synchronized Vertx create(VertxOptions options) { final ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(classloader != null ? classloader : getClass().getClassLoader()); return Vertx.vertx(options); } catch (Exception e) { log.error("Failed to create the vert.x instance", e); } finally { Thread.currentThread().setContextClassLoader(originalClassLoader); } return null; }
/** * @return create a blank new Vert.x instance with @{@code options} closed when tear down executes. */ protected Vertx vertx(VertxOptions options) { if (created == null) { created = new ArrayList<>(); } Vertx vertx = Vertx.vertx(options); created.add(vertx); return vertx; }
/** * @return create a blank new Vert.x instance with no options closed when tear down executes. */ protected Vertx vertx() { if (created == null) { created = new ArrayList<>(); } Vertx vertx = Vertx.vertx(); created.add(vertx); return vertx; }
static Vertx createVertxLoadingMetricsFromMetaInf(VertxOptions options, String factoryFqn) { ClassLoader oldCL = Thread.currentThread().getContextClassLoader(); ClassLoader cl = createMetricsFromMetaInfLoader(factoryFqn); Thread.currentThread().setContextClassLoader(cl); try { return Vertx.vertx(options); } finally { Thread.currentThread().setContextClassLoader(oldCL); } }
@Before public void setUp() { this.vertx = Vertx.vertx(); helloWorldService = Mockito.mock(VertxHelloWorldService.class); }
@Setup public void setup() { vertx = Vertx.vertx(); context = BenchmarkContext.create(vertx); task = v -> consume("the-string"); } }
public void setUp() throws Exception { super.setUp(); vertx.close(); vertx = Vertx.vertx(); eb = vertx.eventBus(); running = true; }
@Test public void testClosingVertxCloseSharedServers() throws Exception { int numServers = 2; Vertx vertx = Vertx.vertx(); List<HttpServerImpl> servers = new ArrayList<>(); for (int i = 0;i < numServers;i++) { HttpServer server = vertx.createHttpServer(createBaseServerOptions()).requestHandler(req -> { }); startServer(server); servers.add((HttpServerImpl) server); } CountDownLatch latch = new CountDownLatch(1); vertx.close(onSuccess(v -> { latch.countDown(); })); awaitLatch(latch); servers.forEach(server -> { assertTrue(server.isClosed()); }); }
@Test public void testFailCreateClusteredVertxSynchronously() { VertxOptions options = new VertxOptions(); options.setClustered(true); try { Vertx.vertx(options); fail("Should throw exception"); } catch (IllegalArgumentException e) { // OK } }
@Test public void testResolveFileFromClasspathDisableCaching() throws Exception { VertxInternal vertx = (VertxInternal) Vertx.vertx(new VertxOptions().setFileResolverCachingEnabled(false)); try { for (int i = 0; i < 2; i++) { File file = vertx.resolveFile("afile.html"); assertTrue(file.exists()); assertTrue(file.getPath().startsWith(".vertx" + File.separator + "file-cache-")); assertFalse(file.isDirectory()); assertEquals("<html><body>afile</body></html>", readFile(file)); } } finally { vertx.close(); } }
@Test public void testDomainSocketClient() throws Exception { File sock = TestUtils.tmpFile(".sock"); vertx = Vertx.vertx(); NetClient client = vertx.createNetClient(); client.connect(SocketAddress.domainSocketAddress(sock.getAbsolutePath()), onFailure(err -> { assertEquals(err.getClass(), IllegalArgumentException.class); testComplete(); })); await(); } }
@Test public void testDomainSocketServer() throws Exception { File sock = TestUtils.tmpFile(".sock"); vertx = Vertx.vertx(); NetServer server = vertx.createNetServer(); server.connectHandler(so -> {}); server.listen(SocketAddress.domainSocketAddress(sock.getAbsolutePath()), onFailure(err -> { assertEquals(err.getClass(), IllegalArgumentException.class); testComplete(); })); await(); }
private void testDefaultDnsClient(Function<Vertx, DnsClient> clientProvider) throws Exception { final String ip = "10.0.0.1"; dnsServer.testLookup4(ip); VertxOptions vertxOptions = new VertxOptions(); InetSocketAddress fakeServerAddress = dnsServer.localAddress(); vertxOptions.getAddressResolverOptions().addServer(fakeServerAddress.getHostString() + ":" + fakeServerAddress.getPort()); Vertx vertxWithFakeDns = Vertx.vertx(vertxOptions); DnsClient dnsClient = clientProvider.apply(vertxWithFakeDns); dnsClient.lookup4("vertx.io", onSuccess(result -> { assertEquals(ip, result); testComplete(); })); await(); vertxWithFakeDns.close(); }
public void setUp() throws Exception { super.setUp(); vinit(); VertxOptions options = getOptions(); boolean nativeTransport = options.getPreferNativeTransport(); vertx = Vertx.vertx(options); if (nativeTransport) { assertTrue(vertx.isNativeTransportEnabled()); } }
@Test public void testMetricsEnabledWithoutConfig() { vertx.close(); vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true))); VertxMetrics metrics = ((VertxInternal) vertx).metricsSPI(); assertNull(metrics); }
@Test public void testSetMetricsInstance() { DummyVertxMetrics metrics = DummyVertxMetrics.INSTANCE; vertx.close(); vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(new SimpleVertxMetricsFactory<>(metrics)))); assertSame(metrics, ((VertxInternal) vertx).metricsSPI()); }
@Test public void testCloseWorkerPoolsWhenVertxCloses() { Vertx vertx = Vertx.vertx(); WorkerExecutor exec = vertx.createSharedWorkerExecutor("vert.x-123"); vertx.close(v -> { try { vertx.executeBlocking(fut -> fail(), ar -> fail()); fail(); } catch (RejectedExecutionException ignore) { } try { exec.executeBlocking(fut -> fail(), ar -> fail()); fail(); } catch (RejectedExecutionException ignore) { } // Check we can still close exec.close(); testComplete(); }); await(); } }