Examples with DummyVertxMetrics io.vertx.core.metrics.impl.DummyVertxMetrics used on opensource projects

Example 6 with DummyVertxMetrics

use of io.vertx.core.metrics.impl.DummyVertxMetrics in project vert.x by eclipse.

the class MetricsContextTest method testDeploy.

private void testDeploy(boolean worker, boolean multiThreaded, BiConsumer<Thread, Context> checker) {
    AtomicReference<Thread> verticleThread = new AtomicReference<>();
    AtomicReference<Context> verticleContext = new AtomicReference<>();
    AtomicBoolean deployedCalled = new AtomicBoolean();
    AtomicBoolean undeployedCalled = new AtomicBoolean();
    VertxMetricsFactory factory = (vertx, options) -> new DummyVertxMetrics() {

        @Override
        public void verticleDeployed(Verticle verticle) {
            deployedCalled.set(true);
            checker.accept(verticleThread.get(), verticleContext.get());
        }

        @Override
        public void verticleUndeployed(Verticle verticle) {
            undeployedCalled.set(true);
            checker.accept(verticleThread.get(), verticleContext.get());
        }
    };
    Vertx vertx = vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(factory)));
    vertx.deployVerticle(new AbstractVerticle() {

        @Override
        public void start() throws Exception {
            verticleThread.set(Thread.currentThread());
            verticleContext.set(Vertx.currentContext());
        }
    }, new DeploymentOptions().setWorker(worker).setMultiThreaded(multiThreaded), ar1 -> {
        assertTrue(ar1.succeeded());
        vertx.undeploy(ar1.result(), ar2 -> {
            assertTrue(ar1.succeeded());
            assertTrue(deployedCalled.get());
            assertTrue(undeployedCalled.get());
            testComplete();
        });
    });
    await();
}

Example 7 with DummyVertxMetrics

use of io.vertx.core.metrics.impl.DummyVertxMetrics in project vert.x by eclipse.

the class MetricsOptionsTest method testMetricsEnabledWithoutConfig.

@Test
public void testMetricsEnabledWithoutConfig() {
    vertx.close();
    vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true)));
    VertxMetrics metrics = ((VertxInternal) vertx).metricsSPI();
    assertNotNull(metrics);
    assertTrue(metrics instanceof DummyVertxMetrics);
}

Example 8 with DummyVertxMetrics

use of io.vertx.core.metrics.impl.DummyVertxMetrics in project vert.x by eclipse.

the class MetricsOptionsTest method testSetMetricsInstanceTakesPrecedenceOverServiceLoader.

@Test
public void testSetMetricsInstanceTakesPrecedenceOverServiceLoader() {
    DummyVertxMetrics metrics = DummyVertxMetrics.INSTANCE;
    vertx.close();
    VertxOptions options = new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(new SimpleVertxMetricsFactory<>(metrics)));
    vertx = createVertxLoadingMetricsFromMetaInf(options, "io.vertx.test.fakemetrics.FakeMetricsFactory");
    assertSame(metrics, ((VertxInternal) vertx).metricsSPI());
}

Example 9 with DummyVertxMetrics

use of io.vertx.core.metrics.impl.DummyVertxMetrics in project vert.x by eclipse.

the class MetricsContextTest method testNetServer.

private void testNetServer(Function<Vertx, Context> contextFactory, BiConsumer<Thread, Context> checker) throws Exception {
    AtomicReference<Thread> expectedThread = new AtomicReference<>();
    AtomicReference<Context> expectedContext = new AtomicReference<>();
    AtomicBoolean socketConnectedCalled = new AtomicBoolean();
    AtomicBoolean socketDisconnectedCalled = new AtomicBoolean();
    AtomicBoolean bytesReadCalled = new AtomicBoolean();
    AtomicBoolean bytesWrittenCalled = new AtomicBoolean();
    AtomicBoolean closeCalled = new AtomicBoolean();
    VertxMetricsFactory factory = (vertx, options) -> new DummyVertxMetrics() {

        @Override
        public TCPMetrics createMetrics(SocketAddress localAddress, NetServerOptions options) {
            return new DummyTCPMetrics() {

                @Override
                public Void connected(SocketAddress remoteAddress, String remoteName) {
                    socketConnectedCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                    return null;
                }

                @Override
                public void disconnected(Void socketMetric, SocketAddress remoteAddress) {
                    socketDisconnectedCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                }

                @Override
                public void bytesRead(Void socketMetric, SocketAddress remoteAddress, long numberOfBytes) {
                    bytesReadCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                }

                @Override
                public void bytesWritten(Void socketMetric, SocketAddress remoteAddress, long numberOfBytes) {
                    bytesWrittenCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                }

                @Override
                public boolean isEnabled() {
                    return true;
                }

                @Override
                public void close() {
                    closeCalled.set(true);
                }
            };
        }
    };
    CountDownLatch latch = new CountDownLatch(1);
    Vertx vertx = vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(factory)));
    Context ctx = contextFactory.apply(vertx);
    ctx.runOnContext(v1 -> {
        NetServer server = vertx.createNetServer().connectHandler(so -> {
            so.handler(buf -> {
                so.write("bye");
            });
        });
        server.listen(1234, "localhost", onSuccess(s -> {
            expectedThread.set(Thread.currentThread());
            expectedContext.set(Vertx.currentContext());
            checker.accept(expectedThread.get(), expectedContext.get());
            latch.countDown();
        }));
    });
    awaitLatch(latch);
    NetClient client = vertx.createNetClient();
    client.connect(1234, "localhost", onSuccess(so -> {
        so.handler(buf -> {
            so.closeHandler(v -> {
                executeInVanillaThread(() -> {
                    vertx.close(v4 -> {
                        assertTrue(bytesReadCalled.get());
                        assertTrue(bytesWrittenCalled.get());
                        assertTrue(socketConnectedCalled.get());
                        assertTrue(socketDisconnectedCalled.get());
                        assertTrue(closeCalled.get());
                        testComplete();
                    });
                });
            });
            so.close();
        });
        so.write("hello");
    }));
    await();
}

Example 10 with DummyVertxMetrics

use of io.vertx.core.metrics.impl.DummyVertxMetrics in project vert.x by eclipse.

the class MetricsContextTest method testNetClient.

private void testNetClient(Function<Vertx, Context> contextFactory, BiConsumer<Thread, Context> checker) throws Exception {
    AtomicReference<Thread> expectedThread = new AtomicReference<>();
    AtomicReference<Context> expectedContext = new AtomicReference<>();
    AtomicBoolean socketConnectedCalled = new AtomicBoolean();
    AtomicBoolean socketDisconnectedCalled = new AtomicBoolean();
    AtomicBoolean bytesReadCalled = new AtomicBoolean();
    AtomicBoolean bytesWrittenCalled = new AtomicBoolean();
    AtomicBoolean closeCalled = new AtomicBoolean();
    VertxMetricsFactory factory = (vertx, options) -> new DummyVertxMetrics() {

        @Override
        public TCPMetrics createMetrics(NetClient client, NetClientOptions options) {
            return new DummyTCPMetrics() {

                @Override
                public Void connected(SocketAddress remoteAddress, String remoteName) {
                    socketConnectedCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                    return null;
                }

                @Override
                public void disconnected(Void socketMetric, SocketAddress remoteAddress) {
                    socketDisconnectedCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                }

                @Override
                public void bytesRead(Void socketMetric, SocketAddress remoteAddress, long numberOfBytes) {
                    bytesReadCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                }

                @Override
                public void bytesWritten(Void socketMetric, SocketAddress remoteAddress, long numberOfBytes) {
                    bytesWrittenCalled.set(true);
                    checker.accept(expectedThread.get(), expectedContext.get());
                }

                @Override
                public boolean isEnabled() {
                    return true;
                }

                @Override
                public void close() {
                    closeCalled.set(true);
                }
            };
        }
    };
    CountDownLatch latch = new CountDownLatch(1);
    Vertx vertx = vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(factory)));
    Context ctx = contextFactory.apply(vertx);
    NetServer server = vertx.createNetServer().connectHandler(so -> {
        so.handler(buf -> {
            so.write("bye");
        });
    });
    server.listen(1234, "localhost", onSuccess(s -> {
        latch.countDown();
    }));
    awaitLatch(latch);
    ctx.runOnContext(v1 -> {
        NetClient client = vertx.createNetClient();
        expectedThread.set(Thread.currentThread());
        expectedContext.set(Vertx.currentContext());
        client.connect(1234, "localhost", onSuccess(so -> {
            so.handler(buf -> {
                so.closeHandler(v -> {
                    assertTrue(bytesReadCalled.get());
                    assertTrue(bytesWrittenCalled.get());
                    assertTrue(socketConnectedCalled.get());
                    assertTrue(socketDisconnectedCalled.get());
                    executeInVanillaThread(() -> {
                        client.close();
                        vertx.close(v4 -> {
                            assertTrue(closeCalled.get());
                            testComplete();
                        });
                    });
                });
                so.close();
            });
            so.write("hello");
        }));
    });
    await();
}