import io.vertx.core.VertxException; //导入依赖的package包/类
public static <T> T await(Consumer<Handler<AsyncResult<T>>> task) {
    CountDownLatch countDownLatch = new CountDownLatch(1);
    try {
        Future<T> f = Future.<T>future().setHandler(ar -> {
            countDownLatch.countDown();
            if (ar.failed()) {
                throw new VertxException(ar.cause());
            }
        });
        task.accept(f.completer());
        countDownLatch.await();
        return f.result();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new VertxException(e);
    }

}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public boolean containsValue(Object value) {
  try {
    return curator.getChildren().forPath(mapPath).stream().anyMatch(k -> {
      try {
        byte[] bytes = curator.getData().forPath(keyPath((K) k));
        KeyValue<K, V> keyValue = asObject(bytes);
        return keyValue.getValue().equals(value);
      } catch (Exception ex) {
        throw new VertxException(ex);
      }
    });
  } catch (Exception e) {
    throw new VertxException(e);
  }
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public V get(Object key) {
  try {
    String keyPath = keyPath((K) key);
    if (null == curator.checkExists().forPath(keyPath)) {
      return null;
    } else {
      KeyValue<K, V> keyValue = asObject(curator.getData().forPath(keyPath));
      return keyValue.getValue();
    }
  } catch (Exception e) {
    if (!(e instanceof KeeperException.NodeExistsException)) {
      throw new VertxException(e);
    }
  }
  return null;
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public V put(K key, V value) {
  try {
    String keyPath = keyPath(key);
    KeyValue<K, V> keyValue = new KeyValue<>(key, value);
    byte[] valueBytes = asByte(keyValue);
    if (get(key) != null) {
      curator.setData().forPath(keyPath, valueBytes);
    } else {
      curator.create().creatingParentsIfNeeded().forPath(keyPath, valueBytes);
    }
    return value;
  } catch (Exception e) {
    throw new VertxException(e);
  }
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler) {
  ContextImpl context = (ContextImpl) vertx.getOrCreateContext();
  // Ordered on the internal blocking executor
  context.executeBlocking(() -> {
    java.util.concurrent.locks.Lock lock = lockService.getLock(name);
    try {
      if (lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
        return new JGroupsLock(vertx, lock);
      } else {
        throw new VertxException("Timed out waiting to get lock " + name);
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new VertxException(e);
    }
  }, resultHandler);
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> handler) {
  Context context = vertx.getOrCreateContext();
  lockCache.getUnchecked(name).whenComplete((lock, error) -> {
    if (error == null) {
      lock.async().tryLock(Duration.ofMillis(timeout)).whenComplete((lockResult, lockError) -> {
        if (lockError == null) {
          if (lockResult.isPresent()) {
            context.runOnContext(v -> Future.<Lock>succeededFuture(new AtomixLock(vertx, lock)).setHandler(handler));
          } else {
            context.runOnContext(v -> Future.<Lock>failedFuture(new VertxException("Timed out waiting to get lock " + name)).setHandler(handler));
          }
        } else {
          context.runOnContext(v -> Future.<Lock>failedFuture(lockError).setHandler(handler));
        }
      });
    } else {
      context.runOnContext(v -> Future.<Lock>failedFuture(error).setHandler(handler));
    }
  });
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  boolean isClusterSerializable = in.readBoolean();
  if (isClusterSerializable) {
    String className = in.readUTF();
    Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
    try {
      data = (T) clazz.newInstance();
      byte[] bytes = new byte[in.read()];
      in.read(bytes);
      ((ClusterSerializable) data).readFromBuffer(0, Buffer.buffer(bytes));
    } catch (InstantiationException | IllegalAccessException e) {
      throw new VertxException(e);
    }
  } else {
    data = (T) in.readObject();
  }
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
public List<MVCRoute> visit() throws IllegalAccessException, InstantiationException {
  instance = clazz.newInstance();
  List<MVCRoute> routes = new ArrayList<>();
  try {
    injectServices();
  } catch (IllegalAccessException iae) {
    throw new VertxException(iae);
  }
  extractFilters();
  for (Method method : methods) {
    MethodVisitor<T> visitor = new MethodVisitor<>(this, method);
    routes.addAll(visitor.visit());
  }
  for (MVCRoute route : routes) {
    route.addProcessorsFirst(processors);
    route.addBeforeFilters(beforeFilters);
    route.addAfterFilters(afterFilters);
  }
  return routes;
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
public void visit() {
  sockJSHandler = SockJSHandler.create(config.getVertx(), config.getSockJSOptions());
  try {
    instance = clazz.newInstance();
    injectServices();
  } catch (Exception e) {
    throw new VertxException("Could not instanciate socket controller : " + clazz.getName(), e);
  }
  EventBusBridge annot = clazz.getAnnotation(EventBusBridge.class);
  path = annot.value();
  BridgeOptions bridge = createBridgeOptions(clazz);
  Map<BridgeEventType, Method> handlers = BridgeEventFactory.createFromController(clazz);
  sockJSHandler.bridge(bridge, be -> {
    Method method = handlers.get(be.type());
    if (method != null) {
      tryToInvoke(instance, method, be);
    } else {
      be.complete(true);
    }
  });
  normalizePath();
  router.route(path).handler(sockJSHandler);
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
public void visit() {
  sockJSHandler = SockJSHandler.create(config.getVertx(), config.getSockJSOptions());
  try {
    instance = clazz.newInstance();
    injectServices();
  } catch (Exception e) {
    throw new VertxException("Could not instanciate socket controller : " + clazz.getName(), e);
  }
  createHandlers();
  sockJSHandler.socketHandler(ws -> {
    openHandlers.forEach(handler -> tryToInvoke(instance, handler, ws, null));
    ws.handler(buff -> messageHandlers.forEach(messageHandler -> tryToInvoke(instance, messageHandler, ws, buff)));
    ws.endHandler(voidz -> closeHandlers.forEach(closeHandler -> tryToInvoke(instance, closeHandler, ws, null)));
  });
  normalizePath();
  router.route(path).handler(sockJSHandler);
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public int readFromBuffer(int pos, Buffer buffer) {
  byte b = buffer.getByte(pos++);
  if (b == (byte)1) {
    int len = buffer.getInt(pos);
    pos += 4;
    byte[] bytes = buffer.getBytes(pos, pos + len);
    pos += len;
    String className = new String(bytes, StandardCharsets.UTF_8);
    try {
      Class clazz = Utils.getClassLoader().loadClass(className);
      ClusterSerializable obj = (ClusterSerializable) clazz.newInstance();
      pos = obj.readFromBuffer(pos, buffer);
      user = (User) obj;
    } catch (Exception e) {
      throw new VertxException(e);
    }
  } else {
    user = null;
  }
  return pos;
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
private synchronized void init() {
  if (gateway == null) {
    boolean connected = false;
    while (!connected) {
      try {
        gateway = new GatewayServer(this, port);
        client = gateway.getCallbackClient().getPort();
        gateway.start();
        connected = true;
      } catch (Exception e) {
        port++;
      }
      if (port > 25340) {
        throw new VertxException("Failed to bind to port");
      }
    }
  }
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public void getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler) {
  ContextImpl context = (ContextImpl) vertx.getOrCreateContext();
  // Ordered on the internal blocking executor
  context.executeBlocking(() -> {
    ISemaphore iSemaphore = hazelcast.getSemaphore(LOCK_SEMAPHORE_PREFIX + name);
    boolean locked = false;
    long remaining = timeout;
    do {
      long start = System.nanoTime();
      try {
        locked = iSemaphore.tryAcquire(remaining, TimeUnit.MILLISECONDS);
      } catch (InterruptedException e) {
        // OK continue
      }
      remaining = remaining - MILLISECONDS.convert(System.nanoTime() - start, NANOSECONDS);
    } while (!locked && remaining > 0);
    if (locked) {
      return new HazelcastLock(iSemaphore);
    } else {
      throw new VertxException("Timed out waiting to get lock " + name);
    }
  }, resultHandler);
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public void authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler) {
  vertx.executeBlocking(fut -> {
    SubjectContext subjectContext = new DefaultSubjectContext();
    Subject subject = securityManager.createSubject(subjectContext);
    String username = authInfo.getString("username");
    String password = authInfo.getString("password");
    AuthenticationToken token = new UsernamePasswordToken(username, password);
    try {
      subject.login(token);
    } catch (AuthenticationException e) {
      throw new VertxException(e);
    }
    fut.complete(new ShiroUser(vertx, securityManager, subject, rolePrefix));
  }, resultHandler);
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public String computeHash(String password, String salt, int version) {

  String concat =
    (salt == null ? "" : salt) +
      password;

  if (version >= 0) {
    if (nonces == null) {
      // the nonce version is not a number
      throw new VertxException("nonces are not available");
    }
    if (version < nonces.size()) {
      concat += nonces.getString(version);
    }
  }

  byte[] bHash = md.digest(concat.getBytes(StandardCharsets.UTF_8));
  if (version >= 0) {
    return bytesToHex(bHash) + '$' + version;
  } else {
    return bytesToHex(bHash);
  }
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
public Future<ApplicationTest> applicationTest() {
    return gradleProperties.version().map(version -> {
            try {
                return new ApplicationTest(hostname(), version);
            } catch (final IOException e) {
                throw new VertxException(e);
            }
        });
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
public static SessionStore adapt(Vertx vertx, SessionStore sessionStore) {
    MessageProducer<String> sessionMessageProducer = vertx.eventBus().sender(VAADIN_SESSION_EXPIRED_ADDRESS);
    if (sessionStore instanceof LocalSessionStoreImpl) {
        return LocalSessionStoreAdapter.of(sessionMessageProducer, (LocalSessionStoreImpl) sessionStore);
    }
    if (sessionStore instanceof ClusteredSessionStoreImpl) {
        return new ClusteredSessionStoreAdapter(sessionMessageProducer, (ClusteredSessionStoreImpl) sessionStore);
    }
    throw new VertxException("Cannot adapt session store of type " + sessionStore.getClass().getName());
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
private VertxVaadin(Vertx vertx, Optional<SessionStore> sessionStore, JsonObject config) {
    this.vertx = Objects.requireNonNull(vertx);
    this.config = Objects.requireNonNull(config);
    this.service = createVaadinService();
    try {
        service.init();
    } catch (Exception ex) {
        throw new VertxException("Cannot initialize Vaadin service", ex);
    }
    SessionStore adaptedSessionStore = SessionStoreAdapter.adapt(vertx, sessionStore.orElseGet(this::createSessionStore));
    this.router = initRouter(adaptedSessionStore);
    this.webSocketHandler = initWebSocketHandler(this.router, adaptedSessionStore);
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public int size() {
  try {
    return curator.getChildren().forPath(mapPath).size();
  } catch (Exception e) {
    throw new VertxException(e);
  }
}
 

import io.vertx.core.VertxException; //导入依赖的package包/类
@Override
public boolean isEmpty() {
  try {
    return curator.getChildren().forPath(mapPath).isEmpty();
  } catch (Exception e) {
    throw new VertxException(e);
  }
}