io.vertx.core.shareddata.Counter Java Examples

private static <T> void openCircuitBreakerAndHandleError(
        Consumer<Throwable> errorHandler,
        ThrowableErrorConsumer<Throwable, T> onFailureRespond,
        Consumer<Throwable> errorMethodHandler,
        Consumer<ExecutionResult<T>> resultConsumer,
        AsyncResult<T> event,
        Lock lock,
        Counter counter) {
    counter.addAndGet(
            LOCK_VALUE,
            val -> {
                lock.release();
                errorHandling(
                        errorHandler,
                        onFailureRespond,
                        errorMethodHandler,
                        resultConsumer,
                        Future.failedFuture(event.cause()));
            });
}
 

private static <T> void openCircuitBreakerAndHandleError(
        Promise<ExecutionResult<T>> _resultHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable e,
    Lock lck,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lck.release();
        final Vertx vertx = vxmsShared.getVertx();
        vertx.executeBlocking(
            bhandler -> {
              T result = handleError(_errorHandler, _onFailureRespond, _errorMethodHandler, e);
              if (!_resultHandler.future().isComplete()) {
                _resultHandler.complete(new ExecutionResult<>(result, true, true, null));
              }
            },
            false,
            res -> {});
      });
}
 

private static <T> void openCircuitBreakerAndHandleError(
    Consumer<Throwable> errorHandler,
    ThrowableErrorConsumer<Throwable, T> onFailureRespond,
    Consumer<Throwable> errorMethodHandler,
    Consumer<ExecutionResult<T>> resultConsumer,
    AsyncResult<T> event,
    Lock lock,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lock.release();
        errorHandling(
            errorHandler,
            onFailureRespond,
            errorMethodHandler,
            resultConsumer,
            Future.failedFuture(event.cause()));
      });
}
 

private static <T> void openCircuitBreakerAndHandleError(
        Consumer<Throwable> errorHandler,
        ThrowableErrorConsumer<Throwable, T> onFailureRespond,
        Consumer<Throwable> errorMethodHandler,
        Consumer<ExecutionResult<T>> resultConsumer,
        AsyncResult<T> event,
        Lock lock,
        Counter counter) {
    counter.addAndGet(
            LOCK_VALUE,
            val -> {
                lock.release();
                errorHandling(
                        errorHandler,
                        onFailureRespond,
                        errorMethodHandler,
                        resultConsumer,
                        Future.failedFuture(event.cause()));
            });
}
 

private static <T> void openCircuitBreakerAndHandleError(
    Consumer<Throwable> errorHandler,
    ThrowableErrorConsumer<Throwable, T> onFailureRespond,
    Consumer<Throwable> errorMethodHandler,
    Consumer<ExecutionResult<T>> resultConsumer,
    AsyncResult<T> event,
    Lock lock,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lock.release();
        errorHandling(
            errorHandler,
            onFailureRespond,
            errorMethodHandler,
            resultConsumer,
            Future.failedFuture(event.cause()));
      });
}
 

private static <T> void openCircuitBreakerAndHandleError(
        Promise<ExecutionResult<T>> _blockingHandler,
        Consumer<Throwable> _errorHandler,
        ThrowableFunction<Throwable, T> _onFailureRespond,
        Consumer<Throwable> _errorMethodHandler,
        VxmsShared vxmsShared,
        Throwable e,
        Lock lck,
        Counter counter) {
    counter.addAndGet(
            LOCK_VALUE,
            val -> {
                lck.release();
                final Vertx vertx = vxmsShared.getVertx();
                vertx.executeBlocking(
                        bhandler -> {
                            T result = handleError(_errorHandler, _onFailureRespond, _errorMethodHandler, e);
                            if (!_blockingHandler.future().isComplete()) {
                                _blockingHandler.complete(new ExecutionResult<>(result, true, true, null));
                            }
                        },
                        false,
                        res -> {
                        });
            });
}
 

@Test
public void testAtomicSyncCounter3() {
  long max = 3;
  vertx
      .sharedData()
      .getCounter(
          "counter1",
          resultHandler -> {
            final Counter counter = resultHandler.result();
            counter.get(
                handler -> {
                  long val = handler.result();
                  if (val == 0) {
                    counter.addAndGet(
                        max,
                        hhh -> {
                          System.out.println("::::" + hhh.result());
                        });
                  } else {

                  }
                });
          });
}
 

private static <T, V> void handleStatefulError(
        String _methodId,
        int _retry,
        long _timeout,
        long _circuitBreakerTimeout,
        ThrowableFutureBiConsumer<T, V> step,
        T inputValue,
        Consumer<Throwable> errorHandler,
        ThrowableErrorConsumer<Throwable, V> onFailureRespond,
        Consumer<Throwable> errorMethodHandler,
        VxmsShared vxmsShared,
        Consumer<ExecutionResult<V>> resultConsumer,
        AsyncResult<V> event,
        Lock lock,
        Counter counter,
        AsyncResult<Long> valHandler) {
    long count = valHandler.result();
    if (count <= DEFAULT_LONG_VALUE) {
        setCircuitBreakerReleaseTimer(_retry, _circuitBreakerTimeout, vxmsShared, counter);
        openCircuitBreakerAndHandleError(
                errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
    } else {
        lock.release();
        retry(
                _methodId,
                _retry,
                _timeout,
                _circuitBreakerTimeout,
                step,
                inputValue,
                errorHandler,
                onFailureRespond,
                errorMethodHandler,
                vxmsShared,
                resultConsumer,
                event);
    }
}
 

private static void setCircuitBreakerReleaseTimer(
        int _retry, long _release, VxmsShared vxmsShared, Counter counter) {
    final long initialRetryCounterValue = (long) (_retry + 1);
    final Vertx vertx = vxmsShared.getVertx();
    vertx.setTimer(_release, timer -> counter.addAndGet(initialRetryCounterValue, val -> {
    }));
}
 

private static <T> void handleStatefulError(
    String _methodId,
    int _retry,
    long _timeout,
    long _circuitBreakerTimeout,
    ThrowableFutureConsumer<T> _userOperation,
    Consumer<Throwable> errorHandler,
    ThrowableErrorConsumer<Throwable, T> onFailureRespond,
    Consumer<Throwable> errorMethodHandler,
    VxmsShared vxmsShared,
    Consumer<ExecutionResult<T>> resultConsumer,
    AsyncResult<T> event,
    Lock lock,
    Counter counter,
    AsyncResult<Long> valHandler) {
  long count = valHandler.result();
  if (count <= DEFAULT_LONG_VALUE) {
    setCircuitBreakerReleaseTimer(_retry, _circuitBreakerTimeout, vxmsShared, counter);
    openCircuitBreakerAndHandleError(
        errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
  } else {
    lock.release();
    retry(
        _methodId,
        _retry,
        _timeout,
        _circuitBreakerTimeout,
        _userOperation,
        errorHandler,
        onFailureRespond,
        errorMethodHandler,
        vxmsShared,
        resultConsumer,
        event);
  }
}
 

private static <T> void executeInitialState(
    int _retry,
    long _timeout,
    ThrowableFutureConsumer<T> _userOperation,
    VxmsShared vxmsShared,
    Promise<T> operationResult,
    Lock lock,
    Counter counter) {
  final long initialRetryCounterValue = (long) (_retry + 1);
  counter.addAndGet(
      initialRetryCounterValue,
      rHandler ->
          executeDefaultState(_timeout, _userOperation, vxmsShared, operationResult, lock));
}
 

private static void setCircuitBreakerReleaseTimer(
    VxmsShared vxmsShared, int _retry, long _circuitBreakerTimeout, Counter counter) {
  final long initialRetryCounterValue = (long) (_retry + 1);
  final Vertx vertx = vxmsShared.getVertx();
  vertx.setTimer(
      _circuitBreakerTimeout, timer -> counter.addAndGet(initialRetryCounterValue, val -> {
      }));
}
 

private static <T> void openCircuitBreakerAndHandleError(
        Promise<ExecutionResult<T>> _blockingHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable e,
    Lock lck,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lck.release();
        final Vertx vertx = vxmsShared.getVertx();
        vertx.executeBlocking(
            bhandler -> {
              T result = handleError(_errorHandler, _onFailureRespond, _errorMethodHandler,
                  _blockingHandler, e);
              if (!_blockingHandler.future().isComplete()) {
                _blockingHandler.complete(new ExecutionResult<>(result, true, true, null));
              }
            },
            false,
            res -> {
            });
      });
}
 

private static <T, V> void executeInitialState(
    String _methodId,
    ThrowableFunction<T, V> step,
    T value,
    Promise<ExecutionResult<V>> _resultHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, V> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable _t,
    int _retry,
    long _timeout,
    long _circuitBreakerTimeout,
    long _delay,
    Lock lock,
    Counter counter) {
  final long initialRetryCounterValue = (long) (_retry + 1);
  counter.addAndGet(
      initialRetryCounterValue,
      rHandler ->
          executeDefault(
              _methodId,
              step,
              value,
              _resultHandler,
              _errorHandler,
              _onFailureRespond,
              _errorMethodHandler,
              vxmsShared,
              _t,
              _retry,
              _timeout,
              _circuitBreakerTimeout,
              _delay,
              lock));
}
 

@Override
public void getCounter(String name, Promise<Counter> promise) {
  vertx.executeBlocking(prom -> {
    if (!counterManager.isDefined(name)) {
      counterManager.defineCounter(name, CounterConfiguration.builder(CounterType.UNBOUNDED_STRONG).build());
    }
    prom.complete(new InfinispanCounter(vertx, counterManager.getStrongCounter(name).sync()));
  }, false, promise);
}
 

private static <T> void executeInitialState(
    String _methodId,
    ThrowableSupplier<T> _supplier,
    Promise<ExecutionResult<T>> _blockingHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable _t,
    int _retry,
    long _timeout,
    long _circuitBreakerTimeout,
    long _delay,
    Lock lock,
    Counter counter) {
  final long initialRetryCounterValue = (long) (_retry + 1);
  counter.addAndGet(
      initialRetryCounterValue,
      rHandler ->
          executeDefault(
              _methodId,
              _supplier,
              _blockingHandler,
              _errorHandler,
              _onFailureRespond,
              _errorMethodHandler,
              vxmsShared,
              _t,
              _retry,
              _timeout,
              _circuitBreakerTimeout,
              _delay,
              lock));
}
 

private static <T> void openCircuitAndHandleError(
    String methodId,
    VxmsShared vxmsShared,
    Consumer<Throwable> errorMethodHandler,
    Message<Object> requestMessage,
    Encoder encoder,
    Consumer<Throwable> errorHandler,
    ThrowableErrorConsumer<Throwable, T> onFailureRespond,
    DeliveryOptions responseDeliveryOptions,
    int retryCount,
    long timeout,
    long circuitBreakerTimeout,
    RecursiveExecutor<T> executor,
    AsyncResult<Message<Object>> event,
    Lock lock,
    Counter counter) {
  resetLockTimer(vxmsShared, retryCount, circuitBreakerTimeout, counter);
  lockAndHandle(
      counter,
      val -> {
        final Throwable cause = event.cause();
        handleError(
            methodId,
            vxmsShared,
            errorMethodHandler,
            requestMessage,
            encoder,
            errorHandler,
            onFailureRespond,
            responseDeliveryOptions,
            retryCount,
            timeout,
            circuitBreakerTimeout,
            executor,
            lock,
            cause);
      });
}
 

private static void resetLockTimer(
    VxmsShared vxmsShared, int retryCount, long circuitBreakerTimeout, Counter counter) {
  final Vertx vertx = vxmsShared.getVertx();
  vertx.setTimer(
      circuitBreakerTimeout,
      timer -> counter.addAndGet(Integer.valueOf(retryCount + 1).longValue(), val -> {}));
}
 

private static <T> void openCircuitAndHandleError(
    String methodId,
    VxmsShared vxmsShared,
    Consumer<Throwable> errorMethodHandler,
    Message<Object> requestMessage,
    Encoder encoder,
    Consumer<Throwable> errorHandler,
    ThrowableFunction<Throwable, T> onFailureRespond,
    DeliveryOptions responseDeliveryOptions,
    int retryCount,
    long timeout,
    long delay,
    long circuitBreakerTimeout,
    RecursiveExecutor<T> executor,
    AsyncResult<Message<Object>> event,
    Lock lock,
    Counter counter) {
  resetLockTimer(vxmsShared, retryCount, circuitBreakerTimeout, counter);
  lockAndHandle(
      counter,
      val -> {
        final Throwable cause = event.cause();
        handleError(
            methodId,
            vxmsShared,
            errorMethodHandler,
            requestMessage,
            encoder,
            errorHandler,
            onFailureRespond,
            responseDeliveryOptions,
            retryCount,
            timeout,
            delay,
            circuitBreakerTimeout,
            executor,
            lock,
            cause);
      });
}
 

private static void resetLockTimer(
    VxmsShared vxmsShared, int retryCount, long circuitBreakerTimeout, Counter counter) {
  final Vertx vertx = vxmsShared.getVertx();
  vertx.setTimer(
      circuitBreakerTimeout,
      timer -> counter.addAndGet(Integer.valueOf(retryCount + 1).longValue(), val -> {}));
}
 

/**
 * 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)));
}
 

private static <T> void executeInitialState(
    int retry,
    long timeout,
    ThrowableFutureConsumer<T> _userOperation,
    VxmsShared vxmsShared,
    Promise<T> operationResult,
    Lock lock,
    Counter counter) {
  final long initialRetryCounterValue = (long) (retry + 1);
  counter.addAndGet(
      initialRetryCounterValue,
      rHandler ->
          executeDefaultState(timeout, _userOperation, vxmsShared, operationResult, lock));
}
 

private static <T> void handleStatefulError(
    String methodId,
    int retry,
    long timeout,
    long circuitBreakerTimeout,
    ThrowableFutureConsumer<T> _userOperation,
    Consumer<Throwable> errorHandler,
    ThrowableErrorConsumer<Throwable, T> onFailureRespond,
    Consumer<Throwable> errorMethodHandler,
    VxmsShared vxmsShared,
    Consumer<ExecutionResult<T>> resultConsumer,
    AsyncResult<T> event,
    Lock lock,
    Counter counter,
    AsyncResult<Long> valHandler) {
  long count = valHandler.result();
  if (count <= DEFAULT_LONG_VALUE) {
    setCircuitBreakerReleaseTimer(retry, circuitBreakerTimeout, vxmsShared.getVertx(), counter);
    openCircuitBreakerAndHandleError(
        errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
  } else {
    lock.release();
    retry(
        methodId,
        retry,
        timeout,
        circuitBreakerTimeout,
        _userOperation,
        errorHandler,
        onFailureRespond,
        errorMethodHandler,
        vxmsShared,
        resultConsumer,
        event);
  }
}
 

private static <T, V> void executeInitialState(
        int retry,
        long timeout,
        ThrowableFutureBiConsumer<T, V> _step,
        T _inputValue,
        VxmsShared vxmsShared,
        Promise<V> operationResult,
        Lock lock,
        Counter counter) {
    final long initialRetryCounterValue = (long) (retry + 1);
    counter.addAndGet(
            initialRetryCounterValue,
            rHandler ->
                    executeDefaultState(timeout, _step, _inputValue, vxmsShared, operationResult, lock));
}
 

private static <T, V> void handleStatefulError(
        String methodId,
        int retry,
        long timeout,
        long circuitBreakerTimeout,
        ThrowableFutureBiConsumer<T, V> _step,
        T _inputValue,
        Consumer<Throwable> errorHandler,
        ThrowableErrorConsumer<Throwable, V> onFailureRespond,
        Consumer<Throwable> errorMethodHandler,
        VxmsShared vxmsShared,
        Consumer<ExecutionResult<V>> resultConsumer,
        AsyncResult<V> event,
        Lock lock,
        Counter counter,
        AsyncResult<Long> valHandler) {
    long count = valHandler.result();
    if (count <= DEFAULT_LONG_VALUE) {
        setCircuitBreakerReleaseTimer(retry, circuitBreakerTimeout, vxmsShared.getVertx(), counter);
        openCircuitBreakerAndHandleError(
                errorHandler, onFailureRespond, errorMethodHandler, resultConsumer, event, lock, counter);
    } else {
        lock.release();
        retry(
                methodId,
                retry,
                timeout,
                circuitBreakerTimeout,
                _step,
                _inputValue,
                errorHandler,
                onFailureRespond,
                errorMethodHandler,
                vxmsShared,
                resultConsumer,
                event);
    }
}
 

private static <T> void executeInitialState(
    String _methodId,
    ThrowableSupplier<T> _supplier,
    Promise<ExecutionResult<T>> _blockingHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable _t,
    int _retry,
    long _timeout,
    long _circuitBreakerTimeout,
    long _delay,
    Lock lock,
    Counter counter) {
  final long initialRetryCounterValue = (long) (_retry + 1);
  counter.addAndGet(
      initialRetryCounterValue,
      rHandler ->
          executeDefault(
              _methodId,
              _supplier,
              _blockingHandler,
              _errorHandler,
              _onFailureRespond,
              _errorMethodHandler,
              vxmsShared,
              _t,
              _retry,
              _timeout,
              _circuitBreakerTimeout,
              _delay,
              lock));
}
 

private static <T> void openCircuitBreakerAndHandleError(
        Promise<ExecutionResult<T>> _blockingHandler,
    Consumer<Throwable> _errorHandler,
    ThrowableFunction<Throwable, T> _onFailureRespond,
    Consumer<Throwable> _errorMethodHandler,
    VxmsShared vxmsShared,
    Throwable e,
    Lock lck,
    Counter counter) {
  counter.addAndGet(
      LOCK_VALUE,
      val -> {
        lck.release();
        final Vertx vertx = vxmsShared.getVertx();
        vertx.executeBlocking(
            bhandler -> {
              T result =
                  handleError(
                      _errorHandler, _onFailureRespond, _errorMethodHandler, _blockingHandler, e);
              if (!_blockingHandler.future().isComplete()) {
                _blockingHandler.complete(new ExecutionResult<>(result, true, true, null));
              }
            },
            false,
            res -> {});
      });
}
 

private static void setCircuitBreakerReleaseTimer(
    VxmsShared vxmsShared, int _retry, long _circuitBreakerTimeout, Counter counter) {
  final Vertx vertx = vxmsShared.getVertx();
  vertx.setTimer(
      _circuitBreakerTimeout,
      timer -> {
        final long initialRetryCounterValue = (long) (_retry + 1);
        counter.addAndGet(initialRetryCounterValue, val -> {});
      });
}
 

private static <T, V> void executeInitialState(
        String _methodId,
        ThrowableFunction<T, V> step,
        T value,
        Promise<ExecutionResult<V>> _blockingHandler,
        Consumer<Throwable> _errorHandler,
        ThrowableFunction<Throwable, V> _onFailureRespond,
        Consumer<Throwable> _errorMethodHandler,
        VxmsShared vxmsShared,
        Throwable _t,
        int _retry,
        long _timeout,
        long _circuitBreakerTimeout,
        long _delay,
        Lock lock,
        Counter counter) {
    final long initialRetryCounterValue = (long) (_retry + 1);
    counter.addAndGet(
            initialRetryCounterValue,
            rHandler ->
                    executeDefault(
                            _methodId,
                            step,
                            value,
                            _blockingHandler,
                            _errorHandler,
                            _onFailureRespond,
                            _errorMethodHandler,
                            vxmsShared,
                            _t,
                            _retry,
                            _timeout,
                            _circuitBreakerTimeout,
                            _delay,
                            lock));
}
 

private static void setCircuitBreakerReleaseTimer(
        VxmsShared vxmsShared, int _retry, long _circuitBreakerTimeout, Counter counter) {
    final Vertx vertx = vxmsShared.getVertx();
    vertx.setTimer(
            _circuitBreakerTimeout,
            timer -> {
                final long initialRetryCounterValue = (long) (_retry + 1);
                counter.addAndGet(initialRetryCounterValue, val -> {
                });
            });
}