Java VertxInternal类代码示例

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
@Override
public Object execute() throws Exception {
    
    ShellTable table = new ShellTable();
    
    table.column("ID");
    table.column("Identifier");
    table.column("Options");
    
    getVertxService().deploymentIDs().forEach(id -> { 
            Deployment deployment = ((VertxInternal)getVertxService()).getDeployment(id);
            Row row = table.addRow();
            row.addContent(id, deployment.verticleIdentifier(), deployment.deploymentOptions().toJson());
        }
    );
    
    try {
        table.print(System.out);
    } catch (Throwable t)  {
        System.err.println("FAILED to write table");
    }
    
    return null;
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
private EmfProvidereHolder lookupHolder() {

    synchronized (vertx) {
      LocalMap<String, EmfProvidereHolder> map = vertx.sharedData().getLocalMap(DS_LOCAL_MAP_NAME);
      EmfProvidereHolder theHolder = map.get(datasourceName);
      if (theHolder == null) {
        theHolder = new EmfProvidereHolder((VertxInternal) vertx, config, map, datasourceName);
      } else {
        theHolder.incRefCount();
      }
      return theHolder;
    }

  }
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
public EmfProvidereHolder(VertxInternal vertx, JsonObject config, LocalMap<String, EmfProvidereHolder> map, String name) {
  this.name = name;
  this.config = config;
  this.vertx = vertx;
  this.map = map;
  this.emfProvider = initializeProvider().setConfig(config).setVertx(vertx);
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
CircuitBreakerMetrics(Vertx vertx, CircuitBreakerImpl circuitBreaker, CircuitBreakerOptions options) {
  this.circuitBreaker = circuitBreaker;
  this.circuitBreakerTimeout = circuitBreaker.options().getTimeout();
  this.circuitBreakerResetTimeout = circuitBreaker.options().getResetTimeout();
  this.node = vertx.isClustered() ? ((VertxInternal) vertx).getClusterManager().getNodeID() : "local";
  this.rollingWindow = new RollingWindow(options.getMetricsRollingWindow(), options.getMetricsRollingBuckets());
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
private String getNodeId(Vertx vertx) {
  if (vertx.isClustered()) {
    return ((VertxInternal) vertx).getNodeID();
  } else {
    return "localhost";
  }
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
@Before
public void setUp() {
  Vertx.clusteredVertx(new VertxOptions(), ar -> {
    ((VertxInternal) ar.result()).getClusterManager().<String, String>getAsyncMap("some-name", x -> {
      map = x.result();
      vertx = ar.result();
    });
  });
  await().until(() -> vertx != null);
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
/**
 * Registers a check which succeeds if a connection with the configured <em>Authentication</em> service can be established.
 *
 * @param readinessHandler The health check handler to register the checks with.
 */
@Override
public void registerReadinessChecks(final HealthCheckHandler readinessHandler) {

    if (dnsClient != null) {
        log.info("registering readiness check using DNS Client");
        readinessHandler.register("authentication-service-availability", status -> {
            log.trace("checking availability of Authentication service");
            dnsClient.lookup(getConfig().getHost(), lookupAttempt -> {
                if (lookupAttempt.succeeded()) {
                    status.tryComplete(Status.OK());
                } else {
                    log.debug("readiness check failed to resolve Authentication service address [{}]: ",
                            getConfig().getHost(), lookupAttempt.cause().getMessage());
                    status.tryComplete(Status.KO());
                }
            });
        });
    } else if (VertxInternal.class.isInstance(vertx)) {
        log.info("registering readiness check using vert.x Address Resolver");
        readinessHandler.register("authentication-service-availability", status -> {
            log.trace("checking availability of Authentication service");
            ((VertxInternal) vertx).resolveAddress(getConfig().getHost(), lookupAttempt -> {
                if (lookupAttempt.succeeded()) {
                    status.tryComplete(Status.OK());
                } else {
                    log.debug("readiness check failed to resolve Authentication service address [{}]: ",
                            getConfig().getHost(), lookupAttempt.cause().getMessage());
                    status.tryComplete(Status.KO());
                };
            });
        });
    } else {
        log.warn("cannot register readiness check, no DNS resolver available");
    }
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
private static String getNodeId(Vertx vertx) {
    if (vertx.isClustered()) {
        return ((VertxInternal) vertx).getNodeID();
    } else {
        return "localhost";
    }
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param cache {@link IgniteCache} instance.
 * @param vertx {@link Vertx} instance.
 */
public AsyncMultiMapImpl(IgniteCache<K, Set<V>> cache, Vertx vertx) {
  cache.unwrap(Ignite.class).events().localListen((IgnitePredicate<Event>)event -> {
    if (!(event instanceof CacheEvent)) {
      throw new IllegalArgumentException("Unknown event received: " + event);
    }

    CacheEvent cacheEvent = (CacheEvent)event;

    if (Objects.equals(cacheEvent.cacheName(), cache.getName()) &&
        ((IgniteCacheProxy)cache).context().localNodeId().equals(cacheEvent.eventNode().id())) {
      K key = unmarshal(cacheEvent.key());

      switch (cacheEvent.type()) {
        case EVT_CACHE_OBJECT_REMOVED:
          subs.remove(key);
          break;

        default:
          throw new IllegalArgumentException("Unknown event received: " + event);
      }
    }

    return true;
  }, EVT_CACHE_OBJECT_REMOVED);

  this.cache = cache;
  this.vertx = (VertxInternal) vertx;
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
public InfinispanAsyncMultiMap(Vertx vertx, Cache<MultiMapKey, Object> cache) {
  this.vertx = (VertxInternal) vertx;
  this.cache = cache;
  nearCache = new ConcurrentHashMap<>();
  cache.addListener(new EntryListener());
  taskQueue = new TaskQueue();
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
private void sendUpdateOnEventBus() {
  vertx.eventBus().publish("circuit-breaker[" + name + "]", new JsonObject()
      .put("name", name)
      .put("state", state)
      .put("failures", failures)
      .put("node", vertx.isClustered() ? ((VertxInternal) vertx).getClusterManager().getNodeID() : "local"));
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
public ExtendedAsyncMapImpl(Vertx vertx, String name) {
  this.vertx = vertx;
  ClusterManager clusterManager = ((VertxInternal) vertx).getClusterManager();
  if (clusterManager == null) {
    syncMap = new ConcurrentHashMap<>();
  } else {
    syncMap = clusterManager.getSyncMap(name);
  }
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
/**
 * Get a local counter. The counter will be passed to the handler.
 *
 * @param name the name of the counter.
 * @param resultHandler the handler
 */
public void getCounter(String name, Handler<AsyncResult<Counter>> resultHandler) {
  Objects.requireNonNull(name, "name");
  Objects.requireNonNull(resultHandler, "resultHandler");
  Counter counter = this.localCounters
      .computeIfAbsent(name, (n) -> new AsynchronousCounter((VertxInternal) this.vertx));
  Context context = this.vertx.getOrCreateContext();
  context.runOnContext((v) -> resultHandler.handle(Future.succeededFuture(counter)));
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
public CommandRegistryImpl(VertxInternal vertx) {
  this.vertx = vertx;
  hook = completionHandler -> {
    try {
      doClose();
      registries.remove(vertx);
    } catch (Exception e) {
      completionHandler.handle(Future.failedFuture(e));
      return;
    }
    completionHandler.handle(Future.succeededFuture());
  };
  vertx.addCloseHook(hook);
}
 

import io.vertx.core.impl.VertxInternal; //导入依赖的package包/类
protected void kill(int pos) {
  VertxInternal v = (VertxInternal) vertices[pos];
  v.executeBlocking(fut -> {
    v.simulateKill();
    fut.complete();
  }, ar -> {
    assertTrue(ar.succeeded());
  });
}