refractor to vertx 3.9.1 , changing Future to Promise for async callback handling

Author: spectralcodex

.idea/compiler.xml

@@ -5,6 +5,7 @@
 import io.vertx.core.AbstractVerticle;
 import io.vertx.core.CompositeFuture;
 import io.vertx.core.Future;
+import io.vertx.core.Promise;
 import io.vertx.core.impl.ConcurrentHashSet;
 import io.vertx.core.json.JsonObject;
 import io.vertx.core.logging.Logger;
@@ -120,50 +121,52 @@ protected Future<Void> publish(Record record) {
  }
  }
 
- Future<Void> future = Future.future();
+ Promise<Void> promise = Promise.promise();
  discovery.publish(record, ar -> {
  if (ar.succeeded()) {
  registeredRecords.add(record);
  logger.info("Service <" + ar.result().getName() + "> published");
- future.complete();
+ promise.complete();
  } else {
  logger.info("Error::Service <" + ar.result().getName() + "> failed published");
- future.fail(ar.cause());
+ promise.fail(ar.cause());
  }
  });
 
- return future;
+ return promise.future();
  }
 
  /**
  * Shutdown and cleanup all resources in discovery service
  *
- * @param stopFuture
+ * @param stopPromise
  * @throws Exception
  */
  @SuppressWarnings("rawtypes")
  @Override
- public void stop(Future<Void> stopFuture) throws Exception {
+ public void stop(Promise<Void> stopPromise) throws Exception {
  List<Future> futures = new ArrayList<>();
  registeredRecords.forEach(record -> {
- Future<Void> cleanUpFuture = Future.future();
- discovery.unpublish(record.getRegistration(), cleanUpFuture.completer());
- futures.add(cleanUpFuture);
+ Promise<Void> cleanUpPromise = Promise.promise();
+ discovery.unpublish(record.getRegistration(), cleanUpPromise);
+ futures.add(cleanUpPromise.future());
  });
 
  if (futures.isEmpty()) {
  discovery.close();
- stopFuture.complete();
+ stopPromise.complete();
  } else {
  CompositeFuture.all(futures)
- .setHandler(ar -> {
+ .onComplete(ar -> {
  discovery.close();
  if (ar.failed()) {
- stopFuture.fail(ar.cause());
+ stopPromise.fail(ar.cause());
  } else {
- stopFuture.complete();
+ stopPromise.complete();
  }
  });
  }
  }
+
+
 }

common-microservice/src/main/java/io/vertx/easyerp/microservice/common/BaseMicroserviceVerticle.java

@@ -3,14 +3,15 @@
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
+import io.vertx.core.Promise;
+import io.vertx.core.http.CookieSameSite;
 import io.vertx.core.http.HttpMethod;
 import io.vertx.core.http.HttpServer;
 import io.vertx.core.json.JsonObject;
 import io.vertx.core.logging.Logger;
 import io.vertx.core.logging.LoggerFactory;
 import io.vertx.ext.web.Router;
 import io.vertx.ext.web.RoutingContext;
-import io.vertx.ext.web.handler.CookieHandler;
 import io.vertx.ext.web.handler.CorsHandler;
 import io.vertx.ext.web.handler.SessionHandler;
 import io.vertx.ext.web.sstore.ClusteredSessionStore;
@@ -33,11 +34,11 @@ public class RestAPIVerticle extends BaseMicroserviceVerticle {
  * @return async result
  */
  protected Future<Void> createHttpServer(Router router, String host, int port) {
- Future<HttpServer> httpServerFuture = Future.future();
+ Promise<HttpServer> httpServerPromise = Promise.promise();
  vertx.createHttpServer()
- .requestHandler(router::accept)
- .listen(port, host, httpServerFuture.completer());
- return httpServerFuture.map(r -> null);
+ .requestHandler(router)
+ .listen(port, host, httpServerPromise);
+ return httpServerPromise.future().map(r -> null);
  }
 
  /**
@@ -70,9 +71,11 @@ protected void enableCorsSupport(Router router) {
  * @param router router instance
  */
  protected void enableLocalSession(Router router) {
- router.route().handler(CookieHandler.create());
+ //router.route().handler(CookieHandler.create()); deprecated
  router.route().handler(SessionHandler.create(
- LocalSessionStore.create(vertx, "erp.user.session")));
+ LocalSessionStore.create(vertx, "erp.user.session"))
+ .setCookieSameSite(CookieSameSite.STRICT)
+ .setCookieSecureFlag(true));
  }
 
  /**
@@ -81,15 +84,17 @@ protected void enableLocalSession(Router router) {
  * @param router Clustered session store
  */
  protected void enableClusteredSession(Router router) {
- router.route().handler(CookieHandler.create());
- router.route().handler(SessionHandler.create(ClusteredSessionStore.create(vertx)));
+ //router.route().handler(CookieHandler.create()); deprecated
+ router.route().handler(SessionHandler.create(ClusteredSessionStore.create(vertx))
+ .setCookieSameSite(CookieSameSite.STRICT)
+ .setCookieSecureFlag(true));
  }
 
  /**
  * Used to validate user login process
  *
  * @param context routing context from rest
- * @param biConsumer
+ * @param biConsumer be able to get both results together
  */
  protected void requireLogin(RoutingContext context, BiConsumer<RoutingContext, JsonObject> biConsumer) {
  Optional<JsonObject> principal = Optional.ofNullable(context.request().getHeader("user-principal"))
@@ -147,9 +152,9 @@ protected <T> Handler<AsyncResult<T>> resultHandler(RoutingContext context, Func
  };
  }
 
- protected <T> Handler<AsyncResult<T>> resultHandlerNonEmpty(RoutingContext context, Function<T, String> converter){
+ protected <T> Handler<AsyncResult<T>> resultHandlerNonEmpty(RoutingContext context, Function<T, String> converter) {
  return ar -> {
- if(ar.succeeded()){
+ if (ar.succeeded()) {
  T res = ar.result();
  if (res == null) {
  notFound(context);
@@ -167,9 +172,9 @@ protected <T> Handler<AsyncResult<T>> resultHandlerNonEmpty(RoutingContext conte
  };
  }
 
- protected <T> Handler<AsyncResult<T>> resultHandlerNonEmpty(RoutingContext context){
+ protected <T> Handler<AsyncResult<T>> resultHandlerNonEmpty(RoutingContext context) {
  return ar -> {
- if(ar.succeeded()){
+ if (ar.succeeded()) {
  T res = ar.result();
  if (res == null) {
  notFound(context);

common-microservice/src/main/java/io/vertx/easyerp/microservice/common/RestAPIVerticle.java

@@ -1,11 +1,10 @@
 package io.vertx.easyerp.microservice.common.service;
 
-import io.vertx.core.AsyncResult;
-import io.vertx.core.Future;
-import io.vertx.core.Handler;
-import io.vertx.core.Vertx;
+import io.vertx.core.*;
 import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
+import io.vertx.core.logging.Logger;
+import io.vertx.core.logging.LoggerFactory;
 import io.vertx.ext.jdbc.JDBCClient;
 import io.vertx.ext.sql.SQLConnection;
 
@@ -19,17 +18,17 @@
  */
 
 public class JdbcRepositoryWrapper {
-
+ private static final Logger logger = LoggerFactory.getLogger(JdbcRepositoryWrapper.class);
  protected final JDBCClient client;
 
  public JdbcRepositoryWrapper(Vertx vertx, JsonObject config) {
- this.client = JDBCClient.createNonShared(vertx, config);
+ this.client = JDBCClient.create(vertx, config);
  }
 
  /**
- * @param params
- * @param sql
- * @param resultHandler
+ * @param params JsonArray containing query parameters
+ * @param sql query
+ * @param resultHandler results
  */
  protected void executeNoResult(JsonArray params, String sql, Handler<AsyncResult<Void>> resultHandler) {
  client.getConnection(connHandler(resultHandler, con ->
@@ -44,11 +43,11 @@ protected void executeNoResult(JsonArray params, String sql, Handler<AsyncResult
  }
 
  /**
- * @param params
- * @param sql
- * @param ret
- * @param resultHandler
- * @param <R>
+ * @param params JsonArray containing query parameters
+ * @param sql query
+ * @param ret result passed
+ * @param resultHandler handler
+ * @param <R> Unknown Object
  */
  protected <R> void execute(JsonArray params, String sql, R ret, Handler<AsyncResult<R>> resultHandler) {
  client.getConnection(connHandler(resultHandler, con ->
@@ -62,30 +61,26 @@ protected <R> void execute(JsonArray params, String sql, R ret, Handler<AsyncRes
  })));
  }
 
- /**
- * @param param
- * @param sql
- * @param <K>
- * @return
- */
+
  protected <K> Future<Optional<JsonObject>> retrieveOne(K param, String sql) {
  return getConnection()
  .compose(con -> {
- Future<Optional<JsonObject>> future = Future.future();
+ Promise<Optional<JsonObject>> promise = Promise.promise();
+
  con.queryWithParams(sql, new JsonArray().add(param), r -> {
  if (r.succeeded()) {
  List<JsonObject> resList = r.result().getRows();
  if (resList == null || resList.isEmpty()) {
- future.complete(Optional.empty());
+ promise.complete(Optional.empty());
  } else {
- future.complete(Optional.of(resList.get(0)));
+ promise.complete(Optional.of(resList.get(0)));
  }
  } else {//hello
- future.fail(r.cause());
+ promise.fail(r.cause());
  }
  con.close();
  });
- return future;
+ return promise.future();
  });
  }
 
@@ -96,16 +91,16 @@ protected <K> Future<Optional<JsonObject>> retrieveOne(K param, String sql) {
  */
  protected Future<List<JsonObject>> retrieveMany(JsonArray param, String sql) {
  return getConnection().compose(con -> {
- Future<List<JsonObject>> future = Future.future();
+ Promise<List<JsonObject>> promise = Promise.promise();
  con.queryWithParams(sql, param, r -> {
  if (r.succeeded()) {
- future.complete(r.result().getRows());
+ promise.complete(r.result().getRows());
  } else {
- future.fail(r.cause());
+ promise.fail(r.cause());
  }
  con.close();
  });
- return future;
+ return promise.future();
  });
  }
 
@@ -115,16 +110,16 @@ protected Future<List<JsonObject>> retrieveMany(JsonArray param, String sql) {
  */
  protected Future<List<JsonObject>> retrieveAll(String sql) {
  return getConnection().compose(con -> {
- Future<List<JsonObject>> future = Future.future();
+ Promise<List<JsonObject>> promise = Promise.promise();
  con.query(sql, r -> {
  if (r.succeeded()) {
- future.complete(r.result().getRows());
+ promise.complete(r.result().getRows());
  } else {
- future.fail(r.cause());
+ promise.fail(r.cause());
  }
  con.close();
  });
- return future;
+ return promise.future();
  });
  }
 
@@ -182,10 +177,17 @@ protected <R> Handler<AsyncResult<SQLConnection>> connHandler(Handler<AsyncResul
  }
 
  protected Future<SQLConnection> getConnection() {
- Future<SQLConnection> future = Future.future();
-
- client.getConnection(future.completer());
- return future;
+ Promise<SQLConnection> promise = Promise.promise();
+ /*client.getConnection(ar ->{
+ if(ar.succeeded())
+ promise.complete(ar.result());
+ else
+ logger.error("Database connection failed, cause is "+ar.cause());
+ promise.fail(ar.cause());
+ });*/
+
+ client.getConnection(promise); //equivalent initial
+ return promise.future();
  }
 }
 

common-microservice/src/main/java/io/vertx/easyerp/microservice/common/service/JdbcRepositoryWrapper.java

@@ -32,7 +32,7 @@
  </modules>
 
  <properties>
- <vertx.version>3.4.1</vertx.version>
+ <vertx.version>3.9.1</vertx.version>
  <mysql.conn.version>6.0.5</mysql.conn.version>
  <log4j.version>2.8</log4j.version>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>