Java Code Examples for io.vertx.core.Context#executeBlocking()

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
    Objects.requireNonNull(supplier);
    VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
    context.<T>executeBlocking(
            fut -> {
                try {
                    fut.complete(supplier.get());
                } catch (Throwable e) {
                    fut.fail(e);
                }
            },
            ar -> {
                if (ar.failed()) {
                    future.completeExceptionally(ar.cause());
                } else {
                    future.complete(ar.result());
                }
            }
    );
    return future;
}
 

private void execute(Object o) {
  if (workerExecutor != null) {
    workerExecutor.executeBlocking(fut -> {
      run(null);
      fut.complete();
    }, ordered, null);
  } else {
    Context ctx = context != null ? context : vertx.getOrCreateContext();
    if (blocking) {
      ctx.executeBlocking(fut -> {
        run(null);
        fut.complete();
      }, ordered, null);
    } else {
      ctx.runOnContext(this::run);
    }
  }
}
 

private void execute(Object arg) {
  if (workerExecutor != null) {
    workerExecutor.executeBlocking(fut -> {
      run(null);
      fut.complete();
    }, ordered, null);
  } else {
    Context ctx = context != null ? context : vertx.getOrCreateContext();
    if (blocking) {
      ctx.executeBlocking(fut -> {
        run(null);
        fut.complete();
      }, ordered, null);
    } else {
      ctx.runOnContext(this::run);
    }
  }
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
    Objects.requireNonNull(supplier);
    VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
    context.<T>executeBlocking(
            fut -> {
                try {
                    fut.complete(supplier.get());
                } catch (Throwable e) {
                    fut.fail(e);
                }
            },
            ar -> {
                if (ar.failed()) {
                    future.completeExceptionally(ar.cause());
                } else {
                    future.complete(ar.result());
                }
            }
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
    Objects.requireNonNull(runnable);
    VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
    context.executeBlocking(
            fut -> {
                try {
                    runnable.run();
                    future.complete(null);
                } catch (Throwable e) {
                    future.completeExceptionally(e);
                }
            },
            null
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
    Objects.requireNonNull(supplier);
    VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
    context.<T>executeBlocking(
            fut -> {
                try {
                    fut.complete(supplier.get());
                } catch (Throwable e) {
                    fut.fail(e);
                }
            },
            ar -> {
                if (ar.failed()) {
                    future.completeExceptionally(ar.cause());
                } else {
                    future.complete(ar.result());
                }
            }
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
    Objects.requireNonNull(runnable);
    VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
    context.executeBlocking(
            fut -> {
                try {
                    runnable.run();
                    future.complete(null);
                } catch (Throwable e) {
                    future.completeExceptionally(e);
                }
            },
            null
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
    Objects.requireNonNull(supplier);
    VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
    context.<T>executeBlocking(
            fut -> {
                try {
                    fut.complete(supplier.get());
                } catch (Throwable e) {
                    fut.fail(e);
                }
            },
            ar -> {
                if (ar.failed()) {
                    future.completeExceptionally(ar.cause());
                } else {
                    future.complete(ar.result());
                }
            }
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
    Objects.requireNonNull(runnable);
    VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
    context.executeBlocking(
            fut -> {
                try {
                    runnable.run();
                    future.complete(null);
                } catch (Throwable e) {
                    future.completeExceptionally(e);
                }
            },
            null
    );
    return future;
}
 

@Override
protected Future<Device> doValidateCredentials(
        final UsernamePasswordCredentials deviceCredentials,
        final CredentialsObject credentialsOnRecord) {

    final Context currentContext = Vertx.currentContext();
    if (currentContext == null) {
        return Future.failedFuture(new IllegalStateException("not running on vert.x Context"));
    } else {
        final Promise<Device> result = Promise.promise();
        currentContext.executeBlocking(blockingCodeHandler -> {
            log.debug("validating password hash on vert.x worker thread [{}]", Thread.currentThread().getName());
            final boolean isValid = credentialsOnRecord.getCandidateSecrets().stream()
                    .anyMatch(candidateSecret -> pwdEncoder.matches(deviceCredentials.getPassword(), candidateSecret));
            if (isValid) {
                blockingCodeHandler.complete(new Device(deviceCredentials.getTenantId(), credentialsOnRecord.getDeviceId()));
            } else {
                blockingCodeHandler.fail(new ClientErrorException(HttpURLConnection.HTTP_UNAUTHORIZED, "bad credentials"));
            }
        }, false, result);
        return result.future();
    }
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
    Objects.requireNonNull(runnable);
    VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
    context.executeBlocking(
            fut -> {
                try {
                    runnable.run();
                    future.complete(null);
                } catch (Throwable e) {
                    future.completeExceptionally(e);
                }
            },
            null
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
    Objects.requireNonNull(supplier);
    VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
    context.<T>executeBlocking(
            fut -> {
                try {
                    fut.complete(supplier.get());
                } catch (Throwable e) {
                    fut.fail(e);
                }
            },
            ar -> {
                if (ar.failed()) {
                    future.completeExceptionally(ar.cause());
                } else {
                    future.complete(ar.result());
                }
            }
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
    Objects.requireNonNull(runnable);
    VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
    context.executeBlocking(
            fut -> {
                try {
                    runnable.run();
                    future.complete(null);
                } catch (Throwable e) {
                    future.completeExceptionally(e);
                }
            },
            null
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
    Objects.requireNonNull(supplier);
    VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
    context.<T>executeBlocking(
            fut -> {
                try {
                    fut.complete(supplier.get());
                } catch (Throwable e) {
                    fut.fail(e);
                }
            },
            ar -> {
                if (ar.failed()) {
                    future.completeExceptionally(ar.cause());
                } else {
                    future.complete(ar.result());
                }
            }
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
    Objects.requireNonNull(runnable);
    VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
    context.executeBlocking(
            fut -> {
                try {
                    runnable.run();
                    future.complete(null);
                } catch (Throwable e) {
                    future.completeExceptionally(e);
                }
            },
            null
    );
    return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
  Objects.requireNonNull(supplier);
  VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
  context.<T>executeBlocking(
      fut -> {
        try {
          fut.complete(supplier.get());
        } catch (Throwable e) {
          fut.fail(e);
        }
      },
      false,
      ar -> {
        if (ar.failed()) {
          future.completeExceptionally(ar.cause());
        } else {
          future.complete(ar.result());
        }
      }
  );
  return future;
}
 

/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
  Objects.requireNonNull(runnable);
  VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
  context.<Void>executeBlocking(
      fut -> {
        try {
          runnable.run();
          fut.complete(null);
        } catch (Throwable e) {
          fut.fail(e);
        }
      },
      false,
      ar -> {
        if (ar.failed()) {
          future.completeExceptionally(ar.cause());
        } else {
          future.complete(ar.result());
        }
      }
  );
  return future;
}