Examples with RetryableAction org.opensearch.action.support.RetryableAction used on opensource projects

Example 1 with RetryableAction

use of org.opensearch.action.support.RetryableAction in project OpenSearch by opensearch-project.

the class ReplicationOperation method performOnReplica.

private void performOnReplica(final ShardRouting shard, final ReplicaRequest replicaRequest, final long globalCheckpoint, final long maxSeqNoOfUpdatesOrDeletes, final PendingReplicationActions pendingReplicationActions) {
    if (logger.isTraceEnabled()) {
        logger.trace("[{}] sending op [{}] to replica {} for request [{}]", shard.shardId(), opType, shard, replicaRequest);
    }
    totalShards.incrementAndGet();
    pendingActions.incrementAndGet();
    final ActionListener<ReplicaResponse> replicationListener = new ActionListener<ReplicaResponse>() {

        @Override
        public void onResponse(ReplicaResponse response) {
            successfulShards.incrementAndGet();
            try {
                updateCheckPoints(shard, response::localCheckpoint, response::globalCheckpoint);
            } finally {
                decPendingAndFinishIfNeeded();
            }
        }

        @Override
        public void onFailure(Exception replicaException) {
            logger.trace(() -> new ParameterizedMessage("[{}] failure while performing [{}] on replica {}, request [{}]", shard.shardId(), opType, shard, replicaRequest), replicaException);
            // Only report "critical" exceptions - TODO: Reach out to the master node to get the latest shard state then report.
            if (TransportActions.isShardNotAvailableException(replicaException) == false) {
                RestStatus restStatus = ExceptionsHelper.status(replicaException);
                shardReplicaFailures.add(new ReplicationResponse.ShardInfo.Failure(shard.shardId(), shard.currentNodeId(), replicaException, restStatus, false));
            }
            String message = String.format(Locale.ROOT, "failed to perform %s on replica %s", opType, shard);
            replicasProxy.failShardIfNeeded(shard, primaryTerm, message, replicaException, ActionListener.wrap(r -> decPendingAndFinishIfNeeded(), ReplicationOperation.this::onNoLongerPrimary));
        }

        @Override
        public String toString() {
            return "[" + replicaRequest + "][" + shard + "]";
        }
    };
    final String allocationId = shard.allocationId().getId();
    final RetryableAction<ReplicaResponse> replicationAction = new RetryableAction<ReplicaResponse>(logger, threadPool, initialRetryBackoffBound, retryTimeout, replicationListener) {

        @Override
        public void tryAction(ActionListener<ReplicaResponse> listener) {
            replicasProxy.performOn(shard, replicaRequest, primaryTerm, globalCheckpoint, maxSeqNoOfUpdatesOrDeletes, listener);
        }

        @Override
        public void onFinished() {
            super.onFinished();
            pendingReplicationActions.removeReplicationAction(allocationId, this);
        }

        @Override
        public boolean shouldRetry(Exception e) {
            final Throwable cause = ExceptionsHelper.unwrapCause(e);
            return cause instanceof CircuitBreakingException || cause instanceof OpenSearchRejectedExecutionException || cause instanceof ConnectTransportException;
        }
    };
    pendingReplicationActions.addPendingAction(allocationId, replicationAction);
    replicationAction.run();
}

Example 2 with RetryableAction

use of org.opensearch.action.support.RetryableAction in project OpenSearch by opensearch-project.

the class RemoteRecoveryTargetHandler method executeRetryableAction.

private <T extends TransportResponse> void executeRetryableAction(String action, RecoveryTransportRequest request, TransportRequestOptions options, ActionListener<T> actionListener, Writeable.Reader<T> reader) {
    final Object key = new Object();
    final ActionListener<T> removeListener = ActionListener.runBefore(actionListener, () -> onGoingRetryableActions.remove(key));
    final TimeValue initialDelay = TimeValue.timeValueMillis(200);
    final TimeValue timeout = recoverySettings.internalActionRetryTimeout();
    final RetryableAction<T> retryableAction = new RetryableAction<T>(logger, threadPool, initialDelay, timeout, removeListener) {

        @Override
        public void tryAction(ActionListener<T> listener) {
            transportService.sendRequest(targetNode, action, request, options, new ActionListenerResponseHandler<>(listener, reader, ThreadPool.Names.GENERIC));
        }

        @Override
        public boolean shouldRetry(Exception e) {
            return retriesSupported && retryableException(e);
        }
    };
    onGoingRetryableActions.put(key, retryableAction);
    retryableAction.run();
    if (isCancelled) {
        retryableAction.cancel(new CancellableThreads.ExecutionCancelledException("recovery was cancelled"));
    }
}