SimpleRetryExecutor.java

package fr.sii.ogham.core.retry;

import java.time.Instant;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.Callable;

import java.util.function.Predicate;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import fr.sii.ogham.core.async.Awaiter;

import fr.sii.ogham.core.exception.async.WaitException;

import fr.sii.ogham.core.exception.retry.ExecutionFailedNotRetriedException;

import fr.sii.ogham.core.exception.retry.ExecutionFailureWrapper;

import fr.sii.ogham.core.exception.retry.MaximumAttemptsReachedException;

import fr.sii.ogham.core.exception.retry.RetryException;

import fr.sii.ogham.core.exception.retry.RetryExecutionInterruptedException;

import fr.sii.ogham.core.exception.retry.UnrecoverableException;

/**

 * A simple implementation that tries to execute the action, if it fails (any

 * exception), it waits using {@link Thread#sleep(long)}. Once the sleep is

 * expired, the action is executed again.

 * 

 * This process is executed until the retry strategy tells that the retries

 * should stop. Once stopped, it means that no execution of the action succeeded

 * so the last exception is thrown.

 * 

 * @author Aurélien Baudet

 *

 */

public class SimpleRetryExecutor implements RetryExecutor {

	/**

	 * Use a provider in order to use a fresh {@link RetryStrategy} strategy

	 * each time the execute method is called. This is mandatory to be able to

	 * use the {@link RetryExecutor} in a multi-threaded application. This

	 * avoids sharing same instance between several {@link #execute(Callable)}

	 * calls.

	 */

	private final RetryStrategyProvider retryProvider;

	/**

	 * Implementation that waits for some time between retries

	 */

	private final Awaiter awaiter;

	/**

	 * Use to check if the exception is recoverable (means that a retry can be

	 * attempted) or not (should fail immediately).

	 */

	private final Predicate<Throwable> recoverable;

	/**

	 * Initializes with a provider in order to use a fresh {@link RetryStrategy}

	 * strategy each time the execute method is called. This is mandatory to be

	 * able to use the {@link RetryExecutor} in a multi-threaded application.

	 * This avoids sharing same instance between several

	 * {@link #execute(Callable)} calls.

	 * Every exception is considered as recoverable (means that retry is attempted).

	 * 

	 * @param retryProvider

	 *            the provider that will provide the retry strategy

	 * @param awaiter

	 *            the waiter that waits some time between retries

	 */

	public SimpleRetryExecutor(RetryStrategyProvider retryProvider, Awaiter awaiter) {

	/**

	 * Initializes with a provider in order to use a fresh {@link RetryStrategy}

	 * strategy each time the execute method is called. This is mandatory to be

	 * able to use the {@link RetryExecutor} in a multi-threaded application.

	 * This avoids sharing same instance between several

	 * {@link #execute(Callable)} calls.

	 * 

	 * @param retryProvider

	 *            the provider that will provide the retry strategy

	 * @param awaiter

	 *            the waiter that waits some time between retries

	 * @param recoverable

	 *            check if the exception is recoverable (means that retry can be

	 *            attempted) or unrecoverable (means that it should fail

	 *            immediately)

	 */

	public SimpleRetryExecutor(RetryStrategyProvider retryProvider, Awaiter awaiter, Predicate<Throwable> recoverable) {

	@Override

	public <V> V execute(Callable<V> actionToRetry) throws RetryException {

		// new instance for each execution

		}

	}

	private <V> V executeWithRetry(Callable<V> actionToRetry, RetryStrategy retry) throws RetryExecutionInterruptedException, MaximumAttemptsReachedException, UnrecoverableException {

		do {

			try {

			}

		// action couldn't be executed

	}

	private <V> void handleFailure(Instant executionStart, Instant executionFailure, Callable<V> actionToRetry, List<Exception> failures, Exception e) throws UnrecoverableException {

		}

	private static <V> V executeWithoutRetry(Callable<V> actionToRetry) throws ExecutionFailedNotRetriedException {

		try {

		}

	}

	private <V> void pause(Instant executionStartTime, Instant executionFailureTime, Callable<V> actionToRetry, RetryStrategy retry, Exception e) throws RetryExecutionInterruptedException {

	private void pauseUntil(Instant nextDate) throws RetryExecutionInterruptedException {

		try {

	private static <V> String getActionName(Callable<V> actionToRetry) {

		}

	}

}

Mutations