Java Future.complete方法代碼示例

import io.vertx.core.Future; //導入方法依賴的package包/類
private Future<String> undeployWebSocketVerticle() {
	Future<String> future = Future.future();
	if(ws_id == null){
		future.complete();
	} else {
		vertx.undeploy(ws_id, res -> {
			  if (res.succeeded()) {
					  ws_id = null;
					  System.out.println("WebsocketVerticle undeployed");
					  future.complete();
				  } else {
					  System.err.println("WebsocketVerticle Undeployment failed: " + res.cause().getMessage()); 
					  future.fail(res.cause());
				  }
		});
	}
	return future;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private void resultOfAuthentication(final AsyncResult<HttpResponse<Buffer>> postReturn,
		final Future<AuthInfo> futureAuthinfo) {
	if (postReturn.succeeded()) {
		// Get session info
		final Buffer body = postReturn.result().body();
		final AuthInfo a = this.extractAuthInfoFromBody(body);
		if (a != null) {
			this.setCachedAuthInfo(a);
			futureAuthinfo.complete(a);
		} else {
			futureAuthinfo.fail("Authentication phase failed, please check log");
		}
	} else {
		futureAuthinfo.fail(postReturn.cause());
	}
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private Future<Void> importBlocks(StorableBlock block) {
    Future<Void> future = Future.future();

    if (config.isTxImport()) {
        listener.onQueueChanged(queue.incrementAndGet());

        storage.put(block, done -> {
            if (done.succeeded()) {
                if (!config.isTxImport()) {
                    listener.onImported(block.getHash(), block.getNumber());
                }
                future.complete();
            } else {
                future.fail(done.cause());
            }
            listener.onQueueChanged(queue.decrementAndGet());
        });
    } else {
        future.complete();
    }
    return future;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private synchronized void readInWorker(Future<ReadResult> future) {
  try {
    ReadResult readResult = new ReadResult();
    readResult.doRead();
    future.complete(readResult);
  } catch (Throwable e) {
    future.fail(e);
  }
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private void completeStartup(AsyncResult<HttpServer> http, Future<Void> fut) {
    if (http.succeeded()) {
        initConfigs();

        LOG.info("SUCCESS: wayf-cloud successfully initialized");
        fut.complete();
    } else {
        LOG.debug("FAILURE: Could not start wayf-cloud due to exception", http.cause());
        fut.fail(http.cause());
    }
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
/**
 * Method to initialize the object so that it can handle deployment and undeployment of components
 *
 * @param isClustered Whether cluster mode is opted
 * @param future      Future to provide the status of initialization
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
void init(Boolean isClustered, Future<Boolean> future) {
	if (isInitialized()) {
		future.complete(false);
		return;
	}

	if (isClustered) {
		sharedData.getLock(RECORDS_LOCK_NAME, lockRes -> {
			if (lockRes.succeeded()) {
				Lock asyncLock = lockRes.result();

				sharedData.<String, String>getClusterWideMap(RECORDS_MAP_NAME, mapRes -> {
					if (mapRes.succeeded()) {
						clusterRecords = mapRes.result();
						future.complete(true);
					} else {
						future.fail(mapRes.cause());
					}

					asyncLock.release();
				});
			} else {
				future.fail(lockRes.cause());
			}
		});

		return;
	}

	localRecords = sharedData.getLocalMap(RECORDS_MAP_NAME);
	future.complete(true);
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
public Future<String> render(String template, JsonObject object) {
    Context context = Context.newBuilder(object.getMap()).resolver(MapValueResolver.INSTANCE).build();
    log.debug("Rendering template {} with object {}", object);
    Future future = Future.future();
    try {
        future.complete(handlebars.compile(template).apply(context));
    } catch (IOException e) {
        log.error("Impossible to render template {}: ", template, e.getMessage());
        future.fail(e.getCause());
    }
    return future;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
public Future<String> render(String template, String destination, JsonObject object) {
  Context context = Context.newBuilder(object.getMap()).resolver(MapValueResolver.INSTANCE).build();
  log.debug("Rendering template {} with object {}", object);
  Future future = Future.future();
  try {
    future.complete(writeFile(destination, handlebars.compile(template).apply(context)));
  } catch (IOException e) {
    log.error("Impossible to render template {}: ", template, e);
    future.fail(e.getCause());
  }
  return future;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
@Override
public SFDCVerticle stopListening(final Future<Void> stopListenFuture) {
	this.logger.info("Stop listening:" + this.getClass().getName());
	this.listening = false;
	if (this.dedupConsumer == null) {
		stopListenFuture.complete();
	} else {
		this.dedupConsumer.unregister(res -> {
			stopListenFuture.complete();
		});
	}
	return this;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
void close(Handler<AsyncResult<Void>> completionHandler) {
  synchronized (vertx) {
    if (--refCount == 0) {
      Future<Void> f1 = Future.future();
      Future<Void> f2 = Future.future();
      if (completionHandler != null) {
        CompositeFuture.all(f1, f2).<Void>map(f -> null).setHandler(completionHandler);
      }
      if (emf != null) {
        vertx.executeBlocking(future -> {
          emf.close();
          future.complete();
        }, f2.completer());
      } else {
        f2.complete();
      }
      try {
        if (exec != null) {
          exec.shutdown();
        }
        if (map != null) {
          map.remove(name);
          if (map.isEmpty()) {
            map.close();
          }
        }
        f1.complete();
      } catch (Throwable t) {
        f1.fail(t);
      }
    } else {
      if (completionHandler != null) {
        completionHandler.handle(Future.succeededFuture());
      }
    }
  }
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
/**
 * Get the count of currently deployed components
 *
 * @param future Future to provide the count of deployed components
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
void count(Future<Integer> future) {
	if (!isInitialized()) {
		future.fail("DeployRecords should be initialized before using it!");
		return;
	}

	if (null == localRecords) {
		sharedData.getLock(RECORDS_LOCK_NAME, lockRes -> {
			if (lockRes.succeeded()) {
				Lock asyncLock = lockRes.result();

				clusterRecords.size(sizeRes -> {
					if (sizeRes.succeeded()) {
						future.complete(sizeRes.result());
					} else {
						future.fail(sizeRes.cause());
					}

					asyncLock.release();
				});
			} else {
				future.fail(lockRes.cause());
			}
		});

		return;
	}

	future.complete(Integer.valueOf(localRecords.size()));
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
public Future<FdfsConnection> get() {
	Future<FdfsConnection> future = Future.future();

	switch (state.get()) {
	case RESERVED:
		pending.add(future);
		break;
	case CONNECTING:
		pending.add(future);
		break;
	case CONNECTED:
		if (this.state.compareAndSet(State.CONNECTED, State.RESERVED)) {
			future.complete(this);
		} else {
			pending.add(future);
		}
		break;
	case DISCONNECTED:
		connect(ar -> {
			if (ar.succeeded()) {
				if (this.state.get() == State.CONNECTED) {
					completeFuture(future);
				} else {
					pending.add(future);
				}
			} else {
				future.fail(ar.cause());
			}
		});
		break;
	default:
		break;
	}

	return future;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
/**
 * Unset / cleanup the deployer completely, by undeploying the components and closing the vert.x instance.
 * You should run 'setup' again, in order to reuse the instance.
 *
 * @param future Vert.x Future object to update the termination status
 * @see <a href="http://vertx.io/docs/apidocs/io/vertx/core/Future.html" target="_blank">Future</a>
 */
public void teardown(Future<Void> future) {
	if (null == this.vertx) {
		logger.warn("Not setup yet! Call 'setup' method first.");
		future.complete();

		return;
	}

	Future<Integer> countFuture = Future.future();

	countFuture.setHandler(sizeRes -> {
		if (sizeRes.succeeded()) {
			if (0 < sizeRes.result()) {
				Future<Void> undeployFuture = Future.future();

				undeployFuture.setHandler(asyncRes -> {
					if (asyncRes.succeeded()) {
						this.closeVertx(future);
					} else {
						future.fail(asyncRes.cause());
					}
				});

				this.undeployAll(undeployFuture);
			} else {
				this.closeVertx(future);
			}
		} else {
			future.fail(sizeRes.cause());
		}
	});

	this.deployRecords.count(countFuture);
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
@Override
public SFDCVerticle stopListening(final Future<Void> stopListenFuture) {
	this.logger.info("Stop listening:" + this.getClass().getName());
	this.listening = false;
	if (this.consumer == null) {
		stopListenFuture.complete();
	} else {
		this.consumer.unregister(res -> {
			stopListenFuture.complete();
		});
	}
	return this;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
/**
 * Loading of the API & WEB UI to provide a minimal Admin GUI to watch the
 * system. WIP
 */
private void startWebServer(final Future<Void> startFuture) {

	// Sanitize the parameters and capture cookies / headers
	// TODO:
	// this.router.route().handler(RequestSanitizer.create(this.vertx));

	final String apiRoute = this.config().getString(Constants.API_ROOT, Constants.API_ROOT);

	// API route
	this.router.route(apiRoute).handler(this::rootHandler);

	// API Routes
	this.setupRouteSecurity(this.router);

	// To be able to access the request body
	this.router.route(apiRoute + "/*").handler(BodyHandler.create());

	// TODO: Deal with failures
	// this.router.route(apiRoute +
	// "/*").failureHandler(this::failureHandler);

	// Allow shutdown with a proper authorized request
	this.router.post(apiRoute + "/shutdown").handler(this::shutdownHandler);

	// Static pages
	this.router.route().handler(StaticHandler.create());

	// Launch the server
	this.logger.info("Listening on port " + Integer.toString(this.appConfig.port));
	this.vertx.createHttpServer().requestHandler(this.router::accept).listen(this.appConfig.port);

	// Finally done
	startFuture.complete();
}