Java Code Examples for io.vertx.core.Vertx

@Path("3")
@GET
public void hello3(@Suspended final AsyncResponse asyncResponse,
	      // Inject the Vertx instance
	      @Context Vertx vertx){
	System.err.println("Creating client");
	HttpClientOptions options = new HttpClientOptions();
	options.setSsl(true);
	options.setTrustAll(true);
	options.setVerifyHost(false);
	HttpClient client = vertx.createHttpClient(options);
	client.getNow(443,
			"www.google.com", 
			"/robots.txt", 
			resp -> {
				System.err.println("Got response");
				resp.bodyHandler(body -> {
					System.err.println("Got body");
					asyncResponse.resume(Response.ok(body.toString()).build());
				});
			});
	System.err.println("Created client");
}
 

private static void initInternal(final Vertx vertx,
                                 final String name) {
    vertxRef = vertx;
    Fn.pool(CONFIGS, name,
            () -> Infix.init(Plugins.Infix.JOOQ,
                    (config) -> {
                        // Initialized client
                        final Configuration configuration = new DefaultConfiguration();
                        configuration.set(SQLDialect.MYSQL_8_0);
                        final ConnectionProvider provider =
                                new DefaultConnectionProvider(HikariCpPool.getConnection(
                                        config.getJsonObject("provider")
                                ));
                        // Initialized default configuration
                        configuration.set(provider);
                        return configuration;
                    }, JooqInfix.class));
}
 

protected CLIENT_POOL findByContext() {
  Context currentContext = Vertx.currentContext();
  if (currentContext != null
      && currentContext.owner() == vertx
      && currentContext.isEventLoopContext()) {
    // standard reactive mode
    CLIENT_POOL clientPool = currentContext.get(id);
    if (clientPool != null) {
      return clientPool;
    }

    // this will make "client.thread-count" bigger than which in microservice.yaml
    // maybe it's better to remove "client.thread-count", just use "rest/highway.thread-count"
    return createClientPool();
  }

  // not in correct context:
  // 1.normal thread
  // 2.vertx worker thread
  // 3.other vertx thread
  // select a existing context
  return nextPool();
}
 

public VertxAsyncSecurityHandler(final Vertx vertx,
                                 final Context context,
                                 final AsyncConfig config, final Pac4jAuthProvider authProvider,
                                 final SecurityHandlerOptions options) {
    super(authProvider);
    CommonHelper.assertNotNull("vertx", vertx);
    CommonHelper.assertNotNull("context", context);
    CommonHelper.assertNotNull("config", config);
    CommonHelper.assertNotNull("config.getClients()", config.getClients());
    CommonHelper.assertNotNull("authProvider", authProvider);
    CommonHelper.assertNotNull("options", options);

    clientNames = options.getClients();
    authorizerName = options.getAuthorizers();
    matcherName = options.getMatchers();
    multiProfile = options.isMultiProfile();
    this.vertx = vertx;
    this.asynchronousComputationAdapter = new VertxAsynchronousComputationAdapter(vertx, context);
    this.context = context;
    this.config = config;

    final DefaultAsyncSecurityLogic<Void, U , VertxAsyncWebContext> securityLogic = new DefaultAsyncSecurityLogic<Void, U, VertxAsyncWebContext>(options.isSaveProfileInSession(),
            options.isMultiProfile(), config, httpActionAdapter);
    securityLogic.setProfileManagerFactory(c -> new VertxAsyncProfileManager(c));
    this.securityLogic = securityLogic;
}
 

@Test
public void testCreationWithVertx() {
  Vertx vertx = Vertx.vertx();
  Fluid fluid = new Fluid(vertx);

  List<String> list = new ArrayList<>();
  FluidRegistry.register("input", Source.from("a", "b", "c"));
  FluidRegistry.register("output", Sink.<String>forEachPayload(list::add));

  fluid.deploy(f -> {
    Sink<String> output = f.sink("output");
    f.<String>from("input")
      .transformPayload(String::toUpperCase)
      .to(output);
  });

  await().until(() -> list.size() == 3);
  assertThat(list).containsExactly("A", "B", "C");
}
 

static void deploy(final Vertx vertx,
                   final Class<?> clazz,
                   final DeploymentOptions option,
                   final Annal logger) {
    // Verticle deployment
    final String name = clazz.getName();
    final String flag = option.isWorker() ? "Worker" : "Agent";
    vertx.deployVerticle(name, option, (result) -> {
        // Success or Failed.
        if (result.succeeded()) {
            logger.info(Info.VTC_END,
                    name, option.getInstances(), result.result(),
                    flag);
            INSTANCES.put(clazz, result.result());
        } else {
            logger.warn(Info.VTC_FAIL,
                    name, option.getInstances(), result.result(),
                    null == result.cause() ? null : result.cause().getMessage(), flag);
        }
    });
}
 

@Before
public void setUp(TestContext context) throws IOException {
    vertx = Vertx.vertx();

    // Pick an available and random
    ServerSocket socket = new ServerSocket(0);
    port = socket.getLocalPort();
    socket.close();

    DeploymentOptions options = new DeploymentOptions()
        .setConfig(new JsonObject()
            .put("HTTP_PORT", port)
            .put("url", "jdbc:hsqldb:mem:test?shutdown=true")
            .put("driver_class", "org.hsqldb.jdbcDriver")
        );
    vertx.deployVerticle(MyFirstVerticle.class.getName(), options, context.asyncAssertSuccess());
}
 

@Path("8")
@GET
public Single<String> hello8(@Context io.vertx.rxjava.core.Vertx rxVertx){
	System.err.println("Creating client");
	WebClientOptions options = new WebClientOptions();
	options.setSsl(true);
	options.setTrustAll(true);
	options.setVerifyHost(false);
	WebClient client = WebClient.create(rxVertx, options);
	Single<HttpResponse<io.vertx.rxjava.core.buffer.Buffer>> responseHandler = client.get(443,
			"www.google.com", 
			"/robots.txt").rxSend();

	System.err.println("Created client");
	return responseHandler.map(body -> {
		System.err.println("Got body");
		return body.body().toString();
	});
}
 

public static void main(String [] args) throws IOException {
    Properties properties = loadProperties("config.properties");
    String messagingHost = properties.getProperty("service.hostname", "messaging.enmasse.svc");
    int messagingPort = Integer.parseInt(properties.getProperty("service.port", "5672"));
    String username = properties.getProperty("service.username", "test");
    String password = properties.getProperty("service.password", "test");

    String maxAddress = properties.getProperty("address.max", "max");
    String controlPrefix = properties.getProperty("address.control.prefix", "control");

    int minTemp = Integer.parseInt(properties.getProperty("control.temperature.min", "15"));
    int maxTemp = Integer.parseInt(properties.getProperty("control.temperature.max", "25"));

    Vertx vertx = Vertx.vertx();
    vertx.deployVerticle(new Thermostat(messagingHost, messagingPort, username, password, maxAddress, controlPrefix, minTemp, maxTemp));
}
 

public static void main(String... args) {

        //Note to self
        // run this demo in HA mode, deploy this verticle on a separate node and combine it with demo6

        final JsonObject config = Config.fromFile("config/demo7.json");

        VertxOptions opts = new VertxOptions().setClustered(true);
        Vertx.clusteredVertx(opts, result -> {
            if (result.succeeded()) {
                LOG.info("Cluster running");
                Vertx vertx = result.result();
                vertx.deployVerticle(BitcoinAdjustedData.class.getName(),
                                     new DeploymentOptions().setConfig(config).setWorker(false));
            } else {
                LOG.error("Clusterin failed");
                throw new RuntimeException(result.cause());
            }
        });
    }
 

public static void main(String... args) {

        final JsonObject config = Config.fromFile("config/demo6.json");

        Vertx vertx = Vertx.vertx();
        vertx.deployVerticle(new JSPercentilesDatasource(), new DeploymentOptions().setConfig(config));

         /*
        Vertx vertx = Vertx.vertx();
        vertx.deployVerticle(new JSAggregateDatasource(), new DeploymentOptions().setConfig(config));
        */

        VertxOptions opts = new VertxOptions().setClustered(true);
        Vertx.clusteredVertx(opts, result -> {
            if(result.succeeded()){
                LOG.info("Cluster running");
                Vertx cvertx = result.result();
                cvertx.deployVerticle(new JSPercentilesDatasource(), new DeploymentOptions().setConfig(config));
            } else {
                LOG.error("Clustering failed");
                throw new RuntimeException(result.cause());
            }
        });
    }
 

@Override
public void start() throws Exception {

    JsonObject config = Vertx.currentContext().config();
    DeploymentOptions opts = new DeploymentOptions().setConfig(config);
    DeploymentOptions chunkOpts = new DeploymentOptions().setConfig(config.copy().put(ADDRESS, "/queryChunk"))
            //.setInstances(config.getInteger(PARALLELISM))
            //.setWorker(true)
            ;

    vertx.deployVerticle("js:io/devcon5/metrics/demo6/AggregatePercentilesVerticle.js",chunkOpts, result -> {
        if (result.succeeded()) {
            LOG.info("JS Verticle successfully deployed {}", result.result());
        } else {
            LOG.error("Failed to deploy JS Verticle", result.cause());
        }
    });
    vertx.deployVerticle(SplitMergeTimeSeriesVerticle.class.getName(), opts);
    vertx.deployVerticle(AnnotationVerticle.class.getName(), opts);
    vertx.deployVerticle(LabelVerticle.class.getName(), opts);
    vertx.deployVerticle(HttpServerVerticle.class.getName(), opts);
}
 

public VertxAsyncLogoutHandler(final Vertx vertx,
                               final Context context,
                               final AsyncConfig<Void, CommonProfile, VertxAsyncWebContext> config,
                               final LogoutHandlerOptions options) {
    DefaultAsyncLogoutLogic<Void, CommonProfile, VertxAsyncWebContext> defaultApplicationLogoutLogic = new DefaultAsyncLogoutLogic<>(config,
            httpActionAdapter,
            options.getDefaultUrl(),
            options.getLogoutUrlPattern(),
            options.isLocalLogout(),
            options.isDestroySession(),
            options.isCentralLogout());
    defaultApplicationLogoutLogic.setProfileManagerFactory(c -> new VertxAsyncProfileManager(c));
    this.logoutLogic = defaultApplicationLogoutLogic;
    this.config = config;
    this.asynchronousComputationAdapter = new VertxAsynchronousComputationAdapter(vertx, context);
}
 

@Test
public void testRoundStrategy() {
	Vertx vertx = Vertx.vertx();
	WebClient http = WebClient.create(vertx);
	App a = new App(vertx,http,"test");
	RoundNodeStrategy w = new RoundNodeStrategy();
	Node n1 = a.createDevNode("10.10.10.1",80,1);
	Node n2 = a.createDevNode("10.10.10.1",80,1);
	Node n3 = a.createDevNode("10.10.10.1",80,1);
	Node n4 = a.createDevNode("10.10.10.1",80,1);
	Node n5 = a.createDevNode("10.10.10.1",80,1);
	w.addNode(n1);
	w.addNode(n2);
	w.addNode(n3);
	w.addNode(n4);
	w.addNode(n5);
	
	
	for(int i=0; i<100 ;i++){
		System.out.println(w.getNode(null).toString());
	}
	
	
}
 

/**
 * @param vertx  Vert.x instance
 * @param config configuration
 * @return ManagedChannel
 */
public static ManagedChannel getChannel(final Vertx vertx,
                                        final JsonObject config) {
    final String rpcHost = config.getString(Key.HOST);
    final Integer rpcPort = config.getInteger(Key.PORT);
    LOGGER.info(Info.CLIENT_RPC, rpcHost, String.valueOf(rpcPort));
    final VertxChannelBuilder builder =
            VertxChannelBuilder
                    .forAddress(vertx, rpcHost, rpcPort);
    Fn.safeSemi(null != config.getValue(Key.SSL), LOGGER,
            () -> {
                final JsonObject sslConfig = config.getJsonObject(Key.SSL);
                if (null != sslConfig && !sslConfig.isEmpty()) {
                    final Object type = sslConfig.getValue("type");
                    final CertType certType = null == type ?
                            CertType.PEM : Types.fromStr(CertType.class, type.toString());
                    final TrustPipe<JsonObject> pipe = TrustPipe.get(certType);
                    // Enable SSL
                    builder.useSsl(pipe.parse(sslConfig));
                } else {
                    builder.usePlaintext(true);
                }
            });
    return builder.build();
}
 

@Override
public Handler<RoutingContext> attack(final Event event) {
    return Fn.get(() -> (context) -> Responser.exec(() -> {
        // 1. Build Envelop
        final Envelop request = this.invoke(context, event);
        // 2. Build event bus
        final Vertx vertx = context.vertx();
        final EventBus bus = vertx.eventBus();
        // 3. Send message
        final String address = this.address(event);
        bus.<Envelop>send(address, request, handler -> {
            final Envelop response;
            if (handler.succeeded()) {
                // Request - Response message
                response = this.success(address, handler);
            } else {
                response = this.failure(address, handler);
            }
            Answer.reply(context, response, event);
        });
    }, context, event), event);
}
 

public HttpContainer(String host, int port, boolean enableLogging) {
  this.host = host;
  this.port = port;
  this.enableLogging = enableLogging;
  vertx = Vertx.vertx();
  HttpServerOptions options = new HttpServerOptions().setLogActivity(this.enableLogging);
  server = vertx.createHttpServer(options);
  router = Router.router(vertx);
}
 

@Before
public void setup() throws Exception {
  vertx = Vertx.vertx();
  httpContainer = new HttpContainer(portNum, true);
  nativeServer = Server.builder().build();
  ClusterManager provisioner = new ClusterManager(nativeServer);
  provisioner.registerWithRouter(httpContainer.getRouter());
  QueryManager qManager = new QueryManager(nativeServer);
  qManager.registerWithRouter(httpContainer.getRouter());
  ActivityLogManager logManager = new ActivityLogManager(nativeServer);
  logManager.registerWithRouter(httpContainer.getRouter());
  EndpointManager endpointManager = new EndpointManager(nativeServer);
  endpointManager.registerWithRouter(httpContainer.getRouter());
  httpContainer.start().get(10, TimeUnit.SECONDS);
}
 

@SuppressWarnings("unchecked")
@Test
public void testRegister() throws Exception {

    final JaxRsRouter jaxRsRouter = new JaxRsRouter();
    final Vertx vertx = Vertx.vertx();
    final Router router = Router.router(vertx);
    final PathsProvider pathsProvider = mock(PathsProvider.class);
    when(pathsProvider.getPathAnnotatedClasses()).thenReturn(Arrays.asList(SampleResource.class));
    jaxRsRouter.register(SampleApp.class, router, pathsProvider, mock(Handler.class));
}
 

@Before
public void prepare(TestContext context) throws InterruptedException {
  vertx = Vertx.vertx();
  JsonObject conf = new JsonObject()
    .put(WikiDatabaseVerticle.CONFIG_WIKIDB_JDBC_URL, "jdbc:hsqldb:mem:testdb;shutdown=true")
    .put(WikiDatabaseVerticle.CONFIG_WIKIDB_JDBC_MAX_POOL_SIZE, 4);
  vertx.deployVerticle(new WikiDatabaseVerticle(), new DeploymentOptions().setConfig(conf),
    context.asyncAssertSuccess(id ->
      service = WikiDatabaseService.createProxy(vertx, WikiDatabaseVerticle.CONFIG_WIKIDB_QUEUE)));
}
 

@Override
public HttpClientWithContext createClientPool() {
  Context context = Vertx.currentContext();
  HttpClient httpClient = context.owner().createHttpClient(httpClientOptions);

  return new HttpClientWithContext(httpClient, context);
}
 

public void init(Vertx vertx, String sslKey, AsyncResultCallback<InetSocketAddress> callback) {
  NetServer netServer;
  if (endpointObject.isSslEnabled()) {
    SSLOptionFactory factory =
        SSLOptionFactory.createSSLOptionFactory(sslKey, null);
    SSLOption sslOption;
    if (factory == null) {
      sslOption = SSLOption.buildFromYaml(sslKey);
    } else {
      sslOption = factory.createSSLOption();
    }
    SSLCustom sslCustom = SSLCustom.createSSLCustom(sslOption.getSslCustomClass());
    NetServerOptions serverOptions = new NetServerOptions();
    VertxTLSBuilder.buildNetServerOptions(sslOption, sslCustom, serverOptions);
    netServer = vertx.createNetServer(serverOptions);
  } else {
    netServer = vertx.createNetServer();
  }

  netServer.connectHandler(netSocket -> {
    TcpServerConnection connection = createTcpServerConnection();
    connection.init(netSocket);
  });

  InetSocketAddress socketAddress = endpointObject.getSocketAddress();
  netServer.listen(socketAddress.getPort(), socketAddress.getHostString(), ar -> {
    if (ar.succeeded()) {
      callback.success(socketAddress);
      return;
    }

    // 监听失败
    String msg = String.format("listen failed, address=%s", socketAddress.toString());
    callback.fail(new Exception(msg, ar.cause()));
  });
}
 

@Override
public void execute(Runnable command) {
  Vertx.currentContext().owner().executeBlocking(future -> {
    command.run();
  },
      false,
      null);
}
 

@Before
public void setUp(TestContext context) throws IOException {
    vertx = Vertx.vertx();

    // Pick an available and random
    ServerSocket socket = new ServerSocket(0);
    port = socket.getLocalPort();
    socket.close();

    DeploymentOptions options = new DeploymentOptions()
        .setConfig(new JsonObject().put("HTTP_PORT", port));
    vertx.deployVerticle(MyFirstVerticle.class.getName(), options, context.asyncAssertSuccess());
}
 

@Before
public void setUp() {
    vertx = Vertx.vertx();
    final AsynchronousComputationAdapter asyncComputationAdapter = new VertxAsynchronousComputationAdapter(vertx, vertx.getOrCreateContext());
    final CompletableFuture<Void> setSessionAttributeFuture;
    webContext = MockAsyncWebContextBuilder.from(vertx, asyncComputationAdapter).build();
}
 

@Test
public void test() throws IOException {
    byte[] bytes = Files.readAllBytes(new File("src/test/resources/config/config.json").toPath());
    JsonObject config = new JsonObject(new String(bytes, "UTF-8"));

    Vertx vertx = Vertx.vertx();

    List<JsonObject> mch = new ArrayList<>();
    List<JsonObject> dvn = new ArrayList<>();
    List<JsonObject> bct = new ArrayList<>();

    vertx.eventBus().consumer(GeneratorConfigVerticle.ADDRESS, message -> {
        JsonObject quote = (JsonObject) message.body();
        System.out.println(quote.encodePrettily());
        assertThat(quote.getDouble("bid")).isGreaterThan(0);
        assertThat(quote.getDouble("ask")).isGreaterThan(0);
        assertThat(quote.getInteger("volume")).isGreaterThan(0);
        assertThat(quote.getInteger("shares")).isGreaterThan(0);
        switch (quote.getString("symbol")) {
            case "MCH":
                mch.add(quote);
                break;
            case "DVN":
                dvn.add(quote);
                break;
            case "BCT":
                bct.add(quote);
                break;
        }
    });

    vertx.deployVerticle(GeneratorConfigVerticle.class.getName(), new DeploymentOptions().setConfig(config));

    await().until(() -> mch.size() > 10);
    await().until(() -> dvn.size() > 10);
    await().until(() -> bct.size() > 10);
}
 

public void example2(Vertx vertx) {
  CoreNLPClient client = CoreNLPClient.create(vertx, new CoreNLPClientOptions());
  client.tokensregex(new RequestParameters().setText("Vert.x created by Tim Fox, maintain by Julien Viet")
                                            .setPattern("[ner: PERSON]")
                                            .setAnnotators(Arrays.asList("tokenize", "ssplit", "pos", "ner", "depparse", "openie")),
                     handler -> {
                       //su
                       if (handler.succeeded()) {
                         // do with result
                         System.out.println(handler.result());
                       } else {
                         System.out.println(handler.cause());
                       }
                     });
}
 

@Before
public void prepare(TestContext context) throws InterruptedException {
  vertx = Vertx.vertx();
  
  JsonObject conf = new JsonObject()  // <1>
    .put(WikiDatabaseVerticle.CONFIG_WIKIDB_JDBC_URL, "jdbc:hsqldb:mem:testdb;shutdown=true")
    .put(WikiDatabaseVerticle.CONFIG_WIKIDB_JDBC_MAX_POOL_SIZE, 4);

  vertx.deployVerticle(new WikiDatabaseVerticle(), new DeploymentOptions().setConfig(conf),
    context.asyncAssertSuccess(id ->  // <2>
      service = WikiDatabaseService.createProxy(vertx, WikiDatabaseVerticle.CONFIG_WIKIDB_QUEUE)));
}
 

public PortfolioServiceVertxEBProxy(Vertx vertx, String address, DeliveryOptions options) {
  this._vertx = vertx;
  this._address = address;
  this._options = options;
  try {
    this._vertx.eventBus().registerDefaultCodec(ServiceException.class,
        new ServiceExceptionMessageCodec());
  } catch (IllegalStateException ex) {}
}
 

public void connecting02(Vertx vertx) {

    // Pool options
    PgPoolOptions options = new PgPoolOptions()
      .setPort(5432)
      .setHost("the-host")
      .setDatabase("the-db")
      .setUsername("user")
      .setPassword("secret")
      .setMaxSize(5);

    // Create the pooled client
    PgPool client = PgClient.pool(vertx, options);
  }
 

@Test /*(timeout=5000)*/  // <8>
public void async_behavior(TestContext context) { // <1>
  Vertx vertx = Vertx.vertx();  // <2>
  context.assertEquals("foo", "foo");  // <3>
  Async a1 = context.async();   // <4>
  Async a2 = context.async(3);  // <5>
  vertx.setTimer(100, n -> a1.complete());  // <6>
  vertx.setPeriodic(100, n -> a2.countDown());  // <7>
}
 

@Override
public void start() throws Exception {

    JsonObject config = Vertx.currentContext().config();
    DeploymentOptions opts = new DeploymentOptions().setConfig(config);
    DeploymentOptions chunkOpts = new DeploymentOptions().setConfig(config.copy().put(ADDRESS, "/queryChunk"));

    vertx.deployVerticle(AggregateTimeSeriesVerticle.class.getName(), chunkOpts);
    vertx.deployVerticle(SplitMergeTimeSeriesVerticle.class.getName(), opts);
    vertx.deployVerticle(AnnotationVerticle.class.getName(), opts);
    vertx.deployVerticle(LabelVerticle.class.getName(), opts);
    vertx.deployVerticle(HttpServerVerticle.class.getName(), opts);

}
 

public void initVertx(@Observes @Initialized(ApplicationScoped.class) Object obj) {

        System.setProperty("vertx.disableDnsResolver", "true");

        this.vertx = Vertx.vertx();

        this.vertx.eventBus().registerDefaultCodec(ChatMessage.class, new ChatMessageCodec());
        this.vertx.eventBus().registerDefaultCodec(PersonName.class, new PersonNameCodec());
        this.vertx.eventBus().registerDefaultCodec(String[].class, new StringArrayCodec());

        allDiscoveredVerticles.forEach(v -> {
            System.out.println("Found verticle "+v);
            vertx.deployVerticle(v);
        });
    }
 

public RpcHolder(
        final Vertx vertx,
        final JsonObject config,
        final Runnable closeRunner) {
    this.vertx = vertx;
    this.config = config;
    this.closeRunner = closeRunner;
}
 

/**
 * Same as {@link #getReceiverRegistrator} but tries to register receiver and returns future with it
 * @param <I> Interface
 * @param vertx Vertx instance
 * @param interfaceType Class for which receiver should be generated
 * @param receiver Interface implementation that should be registered
 * @return Future that on completion returns successfully registered {@link VxRifaReceiver} and fails otherwise
 */
public static <I> Future<VxRifaReceiver<I>> registerReceiver(Vertx vertx, Class<I> interfaceType, I receiver) {
    Future<VxRifaReceiver<I>> future = Future.future();
    
    VxRifaReceiver<I> receiverRegistrator = getReceiverRegistrator(vertx, interfaceType);
    receiverRegistrator.registerReceiver(receiver).setHandler(complete -> {
        if (complete.succeeded()) {
            future.complete(receiverRegistrator);
        } else {
            future.fail(complete.cause());
        }
    });
    
    return future;
}
 

@Before
public void prepare(TestContext context) throws InterruptedException {
  vertx = Vertx.vertx();
  JsonObject conf = new JsonObject()
    .put(WikiDatabaseVerticle.CONFIG_WIKIDB_JDBC_URL, "jdbc:hsqldb:mem:testdb;shutdown=true")
    .put(WikiDatabaseVerticle.CONFIG_WIKIDB_JDBC_MAX_POOL_SIZE, 4);
  vertx.deployVerticle(new WikiDatabaseVerticle(), new DeploymentOptions().setConfig(conf),
    context.asyncAssertSuccess(id ->
      service = io.vertx.guides.wiki.database.WikiDatabaseService.createProxy(vertx, WikiDatabaseVerticle.CONFIG_WIKIDB_QUEUE)));
}
 

public static ManagedChannel getChannel(final Vertx vertx,
                                        final IpcData data) {
    final String grpcHost = data.getHost();
    final Integer grpcPort = data.getPort();
    LOGGER.info(Info.CLIENT_BUILD, grpcHost, String.valueOf(grpcPort));
    final VertxChannelBuilder builder =
            VertxChannelBuilder
                    .forAddress(vertx, grpcHost, grpcPort);
    // Ssl Required
    final JsonObject config = node.read();

    Fn.safeSemi(null != config && null != config.getValue("rpc"), LOGGER,
            () -> {
                // Extension or Uniform
                final JsonObject rpcConfig = config.getJsonObject("rpc");
                final String name = data.getName();
                final JsonObject ssl = RpcHelper.getSslConfig(name, rpcConfig);
                if (ssl.isEmpty()) {
                    // Disabled SSL
                    builder.usePlaintext(true);
                } else {
                    final Object type = ssl.getValue("type");
                    final CertType certType = null == type ?
                            CertType.PEM : Types.fromStr(CertType.class, type.toString());
                    final TrustPipe<JsonObject> pipe = TrustPipe.get(certType);
                    // Enabled SSL
                    builder.useSsl(pipe.parse(ssl));
                }
            });
    return builder.build();
}
 

@Before
public void setUp(final TestContext context) throws IOException {
    vertx = Vertx.vertx();
    final ServerSocket socket = new ServerSocket(0);
    port = socket.getLocalPort();
    socket.close();
    final DeploymentOptions options = new DeploymentOptions()
            .setConfig(new JsonObject().put("http.port", port));
    vertx.deployVerticle(ApiVerticle.class.getName(), options, context.asyncAssertSuccess());
}
 

@Test
	public void test(TestContext context) throws InterruptedException {
//		Async async = context.async();
		Vertx vertx = rule.vertx();

		WebClient client = WebClient.create(vertx);
		HttpRequest<Buffer> req = client.get(41414, "172.21.9.21", "/metrics");
		req.putHeader("aa","ccc");
		 
		req.timeout(50000);
		req.send(ar -> {
			if (ar.succeeded()) {

				HttpResponse<Buffer> response = ar.result();
				System.out.println(response.body());
				System.out.println("Received response with status code" + response.statusCode());
			} else {
				System.out.println("Something went wrong " + ar.cause().getMessage());
			}
//			async.complete();

		});

	
		System.out.println("here1");
//		async.awaitSuccess();
	}
 

@Before
public void setUp(TestContext tc) {
  vertx = Vertx.vertx();

  Async async = tc.async();
  vertx.deployVerticle(io.vertx.workshop.portfolio.impl.PortfolioVerticle.class.getName(), id -> {
    service = ProxyHelper.createProxy(PortfolioService.class, vertx, PortfolioService.ADDRESS);
    service.getPortfolio(ar -> {
      tc.assertTrue(ar.succeeded());
      original = ar.result();
      async.complete();
    });
  });
}