io.vertx.core.Vertx Java Examples

private RPCHandler makeRPCHandler(Vertx vertx) throws Exception {
  Signature.KeyPair keyPair = getLocalKeys();
  String networkKeyBase64 = "1KHLiKZvAvjbY1ziZEHMXawbCEIM6qwjCDm3VYRan/s=";
  Bytes32 networkKeyBytes32 = Bytes32.wrap(Base64.decode(networkKeyBase64));

  String host = "localhost";
  int port = 8008;

  SecureScuttlebuttVertxClient secureScuttlebuttVertxClient =
      new SecureScuttlebuttVertxClient(vertx, keyPair, networkKeyBytes32);

  AsyncResult<RPCHandler> onConnect =
      secureScuttlebuttVertxClient.connectTo(port, host, keyPair.publicKey(), (sender, terminationFn) -> {

        return new RPCHandler(vertx, sender, terminationFn, new ObjectMapper());
      });

  return onConnect.get();
}
 

@BeforeClass
public static void beforeClass(TestContext context) {
    Async before = context.async();
    
    vertx = Vertx.vertx();
    dog = new Pet(1L, new Category(1L, "dog"), "rex", new ArrayList<>(), new ArrayList<>(), StatusEnum.AVAILABLE);
    orderDog = new Order(1L, 1L, 3, OffsetDateTime.of(2017,4,2,11,8,10,0,ZoneOffset.UTC), io.swagger.server.api.model.Order.StatusEnum.APPROVED, Boolean.TRUE);

    // init Main
    vertx.deployVerticle("io.swagger.server.api.MainApiVerticle", res -> {
        if (res.succeeded()) {
            before.complete();
        } else {
            context.fail(res.cause());
        }
    });

    httpClient = Vertx.vertx().createHttpClient();

}
 

/**
 * Default constructor.
 *
 * @param vertx Vert.x object used to build the network components
 * @param listenPort the port to listen to
 * @param networkInterface the network interface to bind to
 * @param advertisedPort the port to advertise in HELLO messages to peers
 * @param identityKeyPair the identity of this client
 * @param subProtocols subprotocols supported
 * @param clientId the client identifier, such as "RLPX 1.2/build 389"
 * @param repository a wire connection repository
 */
public VertxRLPxService(
    Vertx vertx,
    int listenPort,
    String networkInterface,
    int advertisedPort,
    KeyPair identityKeyPair,
    List<SubProtocol> subProtocols,
    String clientId,
    WireConnectionRepository repository) {
  checkPort(listenPort);
  checkPort(advertisedPort);
  if (clientId == null || clientId.trim().isEmpty()) {
    throw new IllegalArgumentException("Client ID must contain a valid identifier");
  }
  this.vertx = vertx;
  this.listenPort = listenPort;
  this.networkInterface = networkInterface;
  this.advertisedPort = advertisedPort;
  this.keyPair = identityKeyPair;
  this.subProtocols = subProtocols;
  this.clientId = clientId;
  this.repository = repository;
}
 

/**
 * Sets up the fixture.
 */
@BeforeEach
public void setUp() {

    final SpanContext spanContext = mock(SpanContext.class);

    span = mock(Span.class);
    when(span.context()).thenReturn(spanContext);
    final SpanBuilder spanBuilder = HonoClientUnitTestHelper.mockSpanBuilder(span);

    final Tracer tracer = mock(Tracer.class);
    when(tracer.buildSpan(anyString())).thenReturn(spanBuilder);

    final Vertx vertx = mock(Vertx.class);
    final ProtonReceiver receiver = HonoClientUnitTestHelper.mockProtonReceiver();
    sender = HonoClientUnitTestHelper.mockProtonSender();

    final RequestResponseClientConfigProperties config = new RequestResponseClientConfigProperties();
    final HonoConnection connection = HonoClientUnitTestHelper.mockHonoConnection(vertx, config);
    when(connection.getTracer()).thenReturn(tracer);

    client = new DeviceConnectionClientImpl(connection, Constants.DEFAULT_TENANT, sender, receiver);
}
 

GrpcHealthReporter(Vertx vertx) {
  this.port = Utils.getFreePort();
  HealthGrpc.HealthImplBase service = new HealthGrpc.HealthImplBase() {
    @Override
    public void check(HealthCheck.HealthCheckRequest request, StreamObserver<HealthCheck.HealthCheckResponse> response) {
      response.onNext(HealthCheck.HealthCheckResponse.newBuilder()
        .setStatus(status)
        .build());
      response.onCompleted();
    }
  };
  server = VertxServerBuilder
    .forPort(vertx, port)
    .addService(service)
    .build();
}
 

@BeforeEach
void setupClient(@TempDirectory Path tempDir, @VertxInstance Vertx vertx) throws Exception {
  knownServersFile = tempDir.resolve("known-hosts.txt");
  Files.write(
      knownServersFile,
      Arrays.asList("#First line", "localhost:" + foobarServer.actualPort() + " " + DUMMY_FINGERPRINT));

  HttpClientOptions options = new HttpClientOptions();
  options
      .setSsl(true)
      .setTrustOptions(VertxTrustOptions.trustServerOnFirstUse(knownServersFile))
      .setConnectTimeout(1500)
      .setReuseAddress(true)
      .setReusePort(true);
  client = vertx.createHttpClient(options);
}
 

public void configureFromDataObject(Vertx vertx) {

    // Data object
    DB2ConnectOptions connectOptions = new DB2ConnectOptions()
      .setPort(50000)
      .setHost("the-host")
      .setDatabase("the-db")
      .setUser("user")
      .setPassword("secret");

    // Pool Options
    PoolOptions poolOptions = new PoolOptions().setMaxSize(5);

    // Create the pool from the data object
    DB2Pool pool = DB2Pool.pool(vertx, connectOptions, poolOptions);

    pool.getConnection(ar -> {
      // Handling your connection
    });
  }
 

public void simpleGetAndHead(Vertx vertx) {

    WebClient client = WebClient.create(vertx);

    // Send a GET request
    client
      .get(8080, "myserver.mycompany.com", "/some-uri")
      .send()
      .onSuccess(response -> System.out
        .println("Received response with status code" + response.statusCode()))
      .onFailure(err ->
        System.out.println("Something went wrong " + err.getMessage()));

    // Send a HEAD request
    client
      .head(8080, "myserver.mycompany.com", "/some-uri")
      .send()
      .onSuccess(response -> System.out
        .println("Received response with status code" + response.statusCode()))
      .onFailure(err ->
        System.out.println("Something went wrong " + err.getMessage()));
  }
 

public OneShotURILoader(Vertx vertx, Map<String, String> config) {
    this.config = config;
    this.vertx = vertx;
    this.defaultOrgName = config.getOrDefault("defaultOrgName", ThreeScaleConstants.DEFAULT_ORGNAME);
    this.defaultVersion = config.getOrDefault("defaultVersion", ThreeScaleConstants.DEFAULT_VERSION);
    this.strategy = RateLimitingStrategy.valueOfOrDefault(config.get("strategy"), RateLimitingStrategy.STANDARD);
    this.apiUri = URI.create(requireOpt("apiEndpoint", "apiEndpoint is required in configuration"));
    this.environment = config.getOrDefault("environment", "production");
    this.backendEndpoint = config.getOrDefault("backendEndpoint", ThreeScaleConstants.DEFAULT_BACKEND);

    if (config.containsKey("policyConfig.overlayUri")) {
        this.policyConfigUri = URI.create(config.get("policyConfig.overlayUri")); // Can be null.
    }

    fetchResource();
}
 

/**
 * Verifies that the <em>getCommandHandlingAdapterInstances</em> operation fails
 * if the adapter instance mapping entry has expired.
 *
 * @param vertx The vert.x instance.
 * @param ctx The vert.x context.
 */
@Test
public void testGetCommandHandlingAdapterInstancesWithExpiredEntry(final Vertx vertx, final VertxTestContext ctx) {
    final String deviceId = "testDevice";
    final String adapterInstance = "adapterInstance";

    final Cache<String, String> mockedCache = spy(cache);
    info = new CacheBasedDeviceConnectionInfo(mockedCache, tracer);
    info.setCommandHandlingAdapterInstance(Constants.DEFAULT_TENANT, deviceId, adapterInstance, Duration.ofMillis(1), span)
    .compose(v -> {
        final Promise<JsonObject> instancesPromise = Promise.promise();
        // wait 2ms to make sure entry has expired after that
        vertx.setTimer(2, tid -> {
            info.getCommandHandlingAdapterInstances(Constants.DEFAULT_TENANT, deviceId,
                    Collections.emptySet(), span)
                    .onComplete(instancesPromise.future());
        });
        return instancesPromise.future();
    }).onComplete(ctx.failing(t -> ctx.verify(() -> {
        assertThat(t).isInstanceOf(ServiceInvocationException.class);
        assertThat(((ServiceInvocationException) t).getErrorCode()).isEqualTo(HttpURLConnection.HTTP_NOT_FOUND);
        ctx.completeNow();
    })));
}
 

@Test
public void findByContext_wrongContext_reverse() {
  HttpClientWithContext pool1 = new HttpClientWithContext(null, null);
  HttpClientWithContext pool2 = new HttpClientWithContext(null, null);
  pools.add(pool1);
  pools.add(pool2);

  new Expectations() {
    {
      Vertx.currentContext();
      result = null;
    }
  };

  AtomicInteger reactiveNextIndex = Deencapsulation.getField(poolMgr, "reactiveNextIndex");
  reactiveNextIndex.set(Integer.MAX_VALUE);
  // each time invoke find, reactiveNextIndex will inc 1
  Assert.assertSame(pool2, poolMgr.findByContext());
  Assert.assertSame(pool1, poolMgr.findByContext());
  Assert.assertSame(pool2, poolMgr.findByContext());
  Assert.assertSame(pool1, poolMgr.findByContext());
}
 

public VertxRestServiceAdapter(Config cfg) {
    // Get the Vertx rest end point configuration
    final String host = cfg.getString("mewbase.api.rest.vertx.host");
    final int port = cfg.getInt("mewbase.api.rest.vertx.port");
    final Duration timeout = cfg.getDuration("mewbase.api.rest.vertx.timeout");
    final HttpServerOptions opts = new HttpServerOptions().setHost(host).setPort(port);

    // Set up the rest server using the config.
    final Vertx vertx = Vertx.vertx();
    httpServer = vertx.createHttpServer(opts);
    router = Router.router(vertx);
    router.route().handler(BodyHandler.create());
    httpServer.requestHandler(router::accept);
    logger.info("Created Rest Adapter on "+ opts.getHost() + ":" + opts.getPort() );
}
 

static void simulateInfluxServer(Vertx vertx, TestContext context, int port, Consumer<String> onRequest) {
  Async ready = context.async();
  vertx.runOnContext(v -> vertx.createHttpServer(new HttpServerOptions()
    .setCompressionSupported(true)
    .setDecompressionSupported(true)
    .setLogActivity(true)
    .setHost("localhost")
    .setPort(port))
    .requestHandler(req -> {
      req.exceptionHandler(context.exceptionHandler());
      req.bodyHandler(buffer -> {
        String str = buffer.toString();
        if (str.isEmpty()) {
          req.response().setStatusCode(200).end();
          return;
        }
        try {
          onRequest.accept(str);
        } finally {
          req.response().setStatusCode(200).end();
        }
      });
    })
    .exceptionHandler(System.err::println)
    .listen(port, "localhost", res -> {
      if (res.succeeded()) {
        ready.complete();
      } else {
        context.fail(res.cause());
      }
    }));
  ready.await(10000);
}
 

public void exampleSharedProducer(Vertx vertx, Map<String, String> config) {
  // Create a shared producer identified by 'the-producer'
  KafkaProducer<String, String> producer1 = KafkaProducer.createShared(vertx, "the-producer", config);

  // Sometimes later you can close it
  producer1.close();
}
 

@RepeatedTest(10)
@DisplayName("Test the validity of references and scoping")
void checkDeployments(Vertx vertx, VertxTestContext testContext) {
  assertThat(testContext).isNotSameAs(previousTestContext);
  previousTestContext = testContext;
  assertThat(vertx).isSameAs(currentVertx);
  assertThat(vertx.deploymentIDs()).isNotEmpty().hasSize(1);
  testContext.completeNow();
}
 

/**
 * Creates a client for a remote authentication server.
 *
 * @param vertx The Vert.x instance to run on.
 * @param connectionFactory The factory.
 * @throws NullPointerException if any of the parameters is {@code null}.
 */
public AuthenticationServerClient(
        final Vertx vertx,
        final ConnectionFactory connectionFactory) {

    this.vertx = Objects.requireNonNull(vertx);
    this.factory = Objects.requireNonNull(connectionFactory);
}
 

@Test
public void loadFromFileNoRef(Vertx vertx, VertxTestContext testContext) {
  OpenAPIHolderImpl parser = new OpenAPIHolderImpl(vertx.createHttpClient(), vertx.fileSystem(), new OpenAPILoaderOptions());

  parser.loadOpenAPI("yaml/valid/simple_spec.yaml").onComplete(testContext.succeeding(container -> {
    testContext.verify(() -> {
      assertThat(container)
          .extracting(JsonPointer.from("/info/title"))
          .isEqualTo("Simple spec no $refs");

      assertThat(container)
          .extracting(JsonPointer.create()
              .append("paths")
              .append("/simple")
              .append("post")
              .append("requestBody")
              .append("content")
              .append("multipart/form-data")
              .append("encoding")
              .append("fileName")
              .append("contentType")
          )
          .isEqualTo("text/plain");

      assertThat(container)
          .extracting(JsonPointer.create()
              .append("paths")
              .append("/simple")
              .append("post")
              .append("responses")
              .append("default")
              .append("description")
          )
          .isEqualTo("unexpected error");
    });
    testContext.completeNow();
  }));
}
 

public void register2(Vertx vertx) {
  ServiceDiscovery.create(vertx)
      .registerServiceImporter(new ZookeeperServiceImporter(),
          new JsonObject()
              .put("connection", "127.0.0.1:2181")
              .put("maxRetries", 5)
              .put("baseSleepTimeBetweenRetries", 2000)
              .put("basePath", "/services")
      );
}
 

@Test(timeout = 30_000L)
public void acquireConnectionsTest(TestContext should) {
  final Vertx vertx = rule.vertx();
  final Async test = should.async();

  Redis client = Redis.createClient(
    vertx,
    new RedisOptions()
      .addConnectionString("redis://localhost:7006")
      .setMaxPoolSize(10)
      .setMaxPoolWaiting(10));

  final AtomicInteger counter = new AtomicInteger();

  // this test asserts that the pools behaves as expected it shall return 10 new connections
  // and will fail on the 21st call as the 10 waiting slots are taken

  vertx.setPeriodic(500, event -> {
    counter.incrementAndGet();
    client.connect(event1 -> {
      if (event1.succeeded()) {
        System.out.println(counter.get());
        should.assertTrue(counter.get() <= 10);
      } else {
        System.out.println(counter.get());
        should.assertTrue(counter.get() == 21);
        vertx.cancelTimer(event);
        test.complete();
      }
    });
  });
}
 

@Before
public void init(TestContext context) throws InterruptedException {
    final WeldVerticle weldVerticle = new WeldVerticle();
    Async async = context.async();
    vertx = Vertx.vertx();
    vertx.deployVerticle(weldVerticle, r -> {
        if (r.succeeded()) {
            weld = weldVerticle.container();
            async.complete();
        } else {
            context.fail(r.cause());
        }
    });
}
 

@Test
public void mountOrAndMixed(Vertx vertx, VertxTestContext testContext) {
  Checkpoint checkpoint = testContext.checkpoint();
  loadFactoryAndStartServer(vertx, SECURITY_TESTS, testContext, routerFactory -> {
    routerFactory.setOptions(FACTORY_OPTIONS);

    routerFactory.operation("listPetsOrAndSecurity").handler(routingContext -> routingContext
      .response()
      .setStatusCode(200)
      .setStatusMessage(concatenateRoutingContextEntries(
        routingContext,
        "api_key",
        "second_api_key",
        "sibling_second_api_key",
        "third_api_key"
      ))
      .end()
    );

    routerFactory.securityHandler("api_key",
      mockFailingAuthHandler(routingContext -> routingContext.put("api_key", "1"))
    );

    routerFactory.securityHandler("second_api_key",
      mockSuccessfulAuthHandler(routingContext -> routingContext.put("second_api_key", "2"))
    );

    routerFactory.securityHandler("sibling_second_api_key",
      mockSuccessfulAuthHandler(routingContext -> routingContext.put("sibling_second_api_key", "3"))
    );

    routerFactory.securityHandler("third_api_key",
      mockFailingAuthHandler(routingContext -> routingContext.put("third_api_key", "4"))
    );
  }).onComplete(h ->
    testRequest(client, HttpMethod.GET, "/pets_or_and_security")
      .expect(statusCode(200), statusMessage("1-2-3-null"))
      .send(testContext, checkpoint)
  );
}
 

private static void resetLockTimer(
    VxmsShared vxmsShared, int retryCount, long circuitBreakerTimeout, Counter counter) {
  final Vertx vertx = vxmsShared.getVertx();
  vertx.setTimer(
      circuitBreakerTimeout,
      timer -> counter.addAndGet(Integer.valueOf(retryCount + 1).longValue(), val -> {}));
}
 

@BeforeAll
public static void before() {
    vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(
            new MicrometerMetricsOptions()
                    .setPrometheusOptions(new VertxPrometheusOptions().setEnabled(true))
                    .setEnabled(true)
    ));
}
 

private DB2Pool initialize(Vertx vertx, DataSourceRuntimeConfig dataSourceRuntimeConfig,
        DataSourceReactiveRuntimeConfig dataSourceReactiveRuntimeConfig,
        DataSourceReactiveDB2Config dataSourceReactiveDB2Config) {
    PoolOptions poolOptions = toPoolOptions(dataSourceRuntimeConfig, dataSourceReactiveRuntimeConfig,
            dataSourceReactiveDB2Config);
    DB2ConnectOptions connectOptions = toConnectOptions(dataSourceRuntimeConfig, dataSourceReactiveRuntimeConfig,
            dataSourceReactiveDB2Config);
    if (dataSourceReactiveRuntimeConfig.threadLocal.isPresent() &&
            dataSourceReactiveRuntimeConfig.threadLocal.get()) {
        return new ThreadLocalDB2Pool(vertx, connectOptions, poolOptions);
    }
    return DB2Pool.pool(vertx, connectOptions, poolOptions);
}
 

@Test
public void shouldSendDataToInfluxDb(TestContext context) throws Exception {
  // Mock an influxdb server
  Async asyncInflux = context.async();
  InfluxDbTestHelper.simulateInfluxServer(vertxForSimulatedServer, context, 8086, body -> {
    if (body.contains("vertx_eventbus_handlers,address=test-eb,metric_type=gauge value=1")) {
      asyncInflux.complete();
    }
  });

  vertx = Vertx.vertx(new VertxOptions()
    .setMetricsOptions(new MicrometerMetricsOptions()
      .setInfluxDbOptions(new VertxInfluxDbOptions()
        .setStep(1)
        .setDb("mydb")
        .setEnabled(true))
      .setRegistryName(REGITRY_NAME)
      .addLabels(Label.EB_ADDRESS)
      .setEnabled(true)));

  // Send something on the eventbus and wait til it's received
  Async asyncEB = context.async();
  vertx.eventBus().consumer("test-eb", msg -> asyncEB.complete());
  vertx.eventBus().publish("test-eb", "test message");
  asyncEB.await(2000);

  // Await influx
  asyncInflux.awaitSuccess(2000);
}
 

public void example4() {
  Vertx vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(
      new DropwizardMetricsOptions()
          .setEnabled(true)
          .setJmxEnabled(true)
          .setJmxDomain("vertx-metrics")));
}
 

@Test
public void test5(Vertx vertx, VertxTestContext testContext) {
  Checkpoint checkpoint = testContext.checkpoint(3);
  assertRequestOk("/test5", "test5_ok_1.json", vertx, testContext, checkpoint);
  assertRequestOk("/test5", "test5_ok_2.json", vertx, testContext, checkpoint);
  assertRequestFail("/test5", "test5_fail.json", vertx, testContext, checkpoint);
}
 

public URILoadingRegistry(Vertx vertx, IEngineConfig vxConfig, Map<String, String> options) {
    super();
    this.vertx = vertx;
    this.options = options;
    Arguments.require(options.containsKey("configUri"), "configUri is required in configuration");
    uri = URI.create(options.get("configUri"));
}
 

private Future<Void> startFileServer(Vertx vertx, VertxTestContext testContext) {
  Router router = Router.router(vertx);
  router.route().handler(StaticHandler.create("src/test/resources"));
  return testContext.assertComplete(
    vertx.createHttpServer()
      .requestHandler(router)
      .listen(9001)
      .mapEmpty()
  );
}
 

@PostConstruct
public void deployVerticle() {
    vertx = Vertx.vertx();

    vertx.deployVerticle(commandResultProcessor, res -> {

    });
    vertx.deployVerticle(mysqlEventStore, res -> {

    });
    vertx.deployVerticle(publishedVersionStore, res -> {

    });
}