io.vertx.core.impl.VertxImpl Java Examples

@Test
public void createClientPool(@Mocked VertxInternal vertx, @Mocked ContextInternal context,
    @Mocked HttpClient httpClient) {
  new Expectations(VertxImpl.class) {
    {
      context.owner();
      result = vertx;
      vertx.createHttpClient(httpClientOptions);
      result = httpClient;
    }
  };
  HttpClientWithContext pool = factory.createClientPool(context);

  Assert.assertSame(context, pool.context());
  Assert.assertSame(httpClient, pool.getHttpClient());
}
 

@Test
public void findByContext_otherVertx(@Mocked VertxImpl otherVertx, @Mocked Context otherContext) {
  HttpClientWithContext pool = new HttpClientWithContext(null, null);
  pools.add(pool);

  new Expectations() {
    {
      Vertx.currentContext();
      result = otherContext;
      otherContext.owner();
      result = otherVertx;
    }
  };

  Assert.assertSame(pool, poolMgr.findByContext());
}
 

public static void deployInference(VertxOptions vertxOptions, DeploymentOptions deploymentOptions, Handler<AsyncResult<InferenceConfiguration>> eventHandler) {
    Vertx vertx = Vertx.vertx(vertxOptions);

    vertx.deployVerticle(clazz(), deploymentOptions, handler -> {
        if (handler.failed()) {
            log.error("Unable to deploy verticle {}", className(), handler.cause());

            if (eventHandler != null) {
                eventHandler.handle(Future.failedFuture(handler.cause()));
            }

            vertx.close();
        } else {
            log.info("Deployed verticle {}", className());
            if (eventHandler != null) {
                VertxImpl vertxImpl = (VertxImpl) vertx;
                DeploymentOptions inferenceDeploymentOptions = vertxImpl.getDeployment(handler.result()).deploymentOptions();

                try {
                    InferenceConfiguration inferenceConfiguration = ObjectMappers.fromJson(inferenceDeploymentOptions.getConfig().encode(), InferenceConfiguration.class);
                    eventHandler.handle(Future.succeededFuture(inferenceConfiguration));
                } catch (Exception exception){
                    log.debug("Unable to parse json configuration into an InferenceConfiguration object. " +
                            "This can be ignored if the verticle isn't an InferenceVerticle.", exception); // TODO: this is done for supporting other verticles in the future. For instance, 'ConverterVerticle'.
                    eventHandler.handle(Future.succeededFuture());
                }
            }
        }
    });
}
 

public Supplier<EventLoopGroup> bossSupplier() {
    return new Supplier<EventLoopGroup>() {
        @Override
        public EventLoopGroup get() {
            return ((VertxImpl) vertx.get()).getAcceptorEventLoopGroup();
        }
    };
}
 

/**
 * Workaround for https://github.com/quarkusio/quarkus/issues/4720 by filtering Vertx multiple instance warning in dev
 * mode.
 */
@BuildStep
void filterMultipleVertxInstancesWarning(LaunchModeBuildItem launchModeBuildItem,
        BuildProducer<LogCleanupFilterBuildItem> logCleanupFilterBuildItemBuildProducer) {
    if (launchModeBuildItem.getLaunchMode().equals(LaunchMode.DEVELOPMENT)) {
        logCleanupFilterBuildItemBuildProducer.produce(new LogCleanupFilterBuildItem(VertxImpl.class.getName(),
                "You're already on a Vert.x context, are you sure you want to create a new Vertx instance"));
    }
}
 

private static void enhanceVertx(String name, Vertx vertx) {
  if (StringUtils.isEmpty(name)) {
    return;
  }
  Field field = ReflectionUtils.findField(VertxImpl.class, "eventLoopThreadFactory");
  field.setAccessible(true);
  VertxThreadFactory eventLoopThreadFactory = (VertxThreadFactory) ReflectionUtils.getField(field, vertx);

  field = ReflectionUtils.findField(eventLoopThreadFactory.getClass(), "prefix");
  field.setAccessible(true);

  String prefix = (String) ReflectionUtils.getField(field, eventLoopThreadFactory);
  ReflectionUtils.setField(field, eventLoopThreadFactory, name + "-" + prefix);
}
 

@Test
public void createClientPool(@Mocked HttpClientWithContext pool) {
  new Expectations(VertxImpl.class) {
    {
      factory.createClientPool(context);
      result = pool;
    }
  };

  Assert.assertSame(pool, poolMgr.createClientPool(context));
  Assert.assertSame(pool, context.get(id));
  Assert.assertThat(pools, Matchers.contains(pool));
}
 

@Override
public void handle(final RoutingContext context) {
    logger.debug("got request");
    final HttpServerRequest request = context.request();
    final HttpServerResponse response = context.response();
    response.putHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
    response.putHeader("Pragma", "no-cache");
    if (request.params().contains("host") && request.params().contains("port")) {
        AuthSession authPreSession = null;
        if (authentication) {
            authPreSession = WebHelper.validateCookie(context);
            if (authPreSession == null) {
                response.setStatusCode(410);
                response.end("session invalid");
                return;
            }
        }
        final AuthSession authSession = authPreSession;
        final String host = request.params().get("host");
        final int port = Integer.parseInt(request.params().get("port"));
        final UUID sid = UUID.randomUUID();
        final String clienthost = RequestHelper.getRemoteHost(request);
        if (sessions.size() >= sessionlimit) {
            response.setStatusCode(410);
            response.end("session limit reached");
            logger.warn("ssh session limit of " + sessionlimit + " reached");
            return;
        }
        ((VertxImpl) vertx).resolveAddress(host, result -> {
            if (result.succeeded()) {
                final InetAddress address = result.result();
                vertx.<Boolean>executeBlocking(promise -> {
                    final boolean isAllowed = AccessHelper.isHostAllowed(accessList, whiteList, blackList, address, authSession);
                    promise.complete(isAllowed);
                }, false, res -> {
                    if (res.succeeded()) {
                        if (!res.result()) {
                            response.setStatusCode(410);
                            response.end("host not allowed");
                            logger.warn("client " + clienthost + " " + (authSession == null ? "" : "(" + authSession + ")") + " tried to access " + address.getHostAddress() + " but was not allowed");
                        } else {
                            connectTcpEndpoint(sid, address.getHostAddress(), port, clienthost).future().onComplete(ar -> {
                                if (ar.succeeded()) {
                                    response.setStatusCode(200);
                                    response.end(sid.toString());
                                } else {
                                    response.setStatusCode(500);
                                    response.end("could not init ssh session");
                                }
                            });
                        }
                    } else {
                        logger.error(res.cause().getMessage(), res.cause());
                        response.setStatusCode(500);
                        response.end("internal server error");
                    }
                });
            } else {
                response.setStatusCode(410);
                response.end("invalid host");
            }
        });
    } else {
        response.setStatusCode(410);
        response.end("error");
    }
}