FixedIntervalBuilder.java

package fr.sii.ogham.core.builder.retry;

import fr.sii.ogham.core.builder.Builder;

import fr.sii.ogham.core.builder.configuration.ConfigurationValueBuilder;

import fr.sii.ogham.core.builder.configuration.ConfigurationValueBuilderHelper;

import fr.sii.ogham.core.builder.configurer.Configurer;

import fr.sii.ogham.core.builder.context.BuildContext;

import fr.sii.ogham.core.builder.env.EnvironmentBuilder;

import fr.sii.ogham.core.fluent.AbstractParent;

import fr.sii.ogham.core.retry.FixedIntervalRetry;

import fr.sii.ogham.core.retry.RetryExecutor;

import fr.sii.ogham.core.retry.RetryStrategy;

import fr.sii.ogham.core.retry.SimpleRetryExecutor;

/**

 * Configures retry handling based on a fixed interval (based on first execution

 * start date).

 * 

 * Retry several times with a fixed interval between each try until the maximum

 * attempts is reached. The interval is based on the first execution start date.

 * 

 * For example:

 * 

 * <pre>

 * .fixedInterval()

 *    .interval(500)

 *    .maxRetries(5)

 * </pre>

 * 

 * Means that a retry will be attempted every 500ms until 5 attempts are reached

 * (inclusive). For example, you want to connect to an external system at t1=0

 * and the connection timeout (100ms) is triggered at t2=100ms. Using this retry

 * will provide the following behavior:

 * 

 * 

 * <ul>

 * <li>0: connect</li>

 * <li>100: timeout</li>

 * <li>500: connect</li>

 * <li>600: timeout</li>

 * <li>1000: connect</li>

 * <li>1100: timeout</li>

 * <li>1500: connect</li>

 * <li>1600: timeout</li>

 * <li>2000: connect</li>

 * <li>2100: timeout</li>

 * <li>2500: connect</li>

 * <li>2600: timeout</li>

 * <li>fail</li>

 * </ul>

 * 

 * 

 * <strong>NOTE:</strong> The provided date doesn't take the duration of the

 * execution in account. If an execution takes 1s to execute while retry delay

 * is set to 500ms, there may have several executions in parallel. However, this

 * totally depends on the {@link RetryExecutor} implementation. For example

 * {@link SimpleRetryExecutor} won't run several executions in parallel. In this

 * case, it will execute the action as soon as the previous one has failed

 * therefore the delay may not be complied.

 * 

 * 

 * @author Aurélien Baudet

 *

 * @param <P>

 *            the type of the parent builder (when calling {@link #and()}

 *            method)

 */

public class FixedIntervalBuilder<P> extends AbstractParent<P> implements Builder<RetryStrategy> {

	private final BuildContext buildContext;

	private final ConfigurationValueBuilderHelper<FixedIntervalBuilder<P>, Integer> maxRetriesValueBuilder;

	private final ConfigurationValueBuilderHelper<FixedIntervalBuilder<P>, Long> intervalValueBuilder;

	/**

	 * Initializes the builder with a parent builder. The parent builder is used

	 * when calling {@link #and()} method. The {@link EnvironmentBuilder} is

	 * used to evaluate properties when {@link #build()} method is called.

	 * 

	 * @param parent

	 *            the parent builder

	 * @param buildContext

	 *            for registering instances and property evaluation

	 */

	public FixedIntervalBuilder(P parent, BuildContext buildContext) {

	/**

	 * Set the maximum number of attempts.

	 * 

	 * <p>

	 * The value set using this method takes precedence over any property and

	 * default value configured using {@link #maxRetries()}.

	 * 

	 * <pre>

	 * .maxRetries(10)

	 * .maxRetries()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(5)

	 * </pre>

	 * 

	 * <pre>

	 * .maxRetries(10)

	 * .maxRetries()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(5)

	 * </pre>

	 * 

	 * In both cases, {@code maxRetries(10)} is used.

	 * 

	 * <p>

	 * If this method is called several times, only the last value is used.

	 * 

	 * <p>

	 * If {@code null} value is set, it is like not setting a value at all. The

	 * property/default value configuration is applied.

	 * 

	 * @param maxRetries

	 *            the maximum number of attempts

	 * @return this instance for fluent chaining

	 */

	public FixedIntervalBuilder<P> maxRetries(Integer maxRetries) {

	}

	/**

	 * Set the maximum number of attempts.

	 * 

	 * <p>

	 * This method is mainly used by {@link Configurer}s to register some

	 * property keys and/or a default value. The aim is to let developer be able

	 * to externalize its configuration (using system properties, configuration

	 * file or anything else). If the developer doesn't configure any value for

	 * the registered properties, the default value is used (if set).

	 * 

	 * <pre>

	 * .maxRetries()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(5)

	 * </pre>

	 * 

	 * <p>

	 * Non-null value set using {@link #maxRetries(Integer)} takes precedence

	 * over property values and default value.

	 * 

	 * <pre>

	 * .maxRetries(10)

	 * .maxRetries()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(5)

	 * </pre>

	 * 

	 * The value {@code 10} is used regardless of the value of the properties

	 * and default value.

	 * 

	 * <p>

	 * See {@link ConfigurationValueBuilder} for more information.

	 * 

	 * 

	 * @return the builder to configure property keys/default value

	 */

	public ConfigurationValueBuilder<FixedIntervalBuilder<P>, Integer> maxRetries() {

	}

	/**

	 * Set the interval between two executions (in milliseconds).

	 * 

	 * <p>

	 * The value set using this method takes precedence over any property and

	 * default value configured using {@link #interval()}.

	 * 

	 * <pre>

	 * .interval(5000L)

	 * .interval()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(10000L)

	 * </pre>

	 * 

	 * <pre>

	 * .interval(5000L)

	 * .interval()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(10000L)

	 * </pre>

	 * 

	 * In both cases, {@code interval(5000L)} is used.

	 * 

	 * <p>

	 * If this method is called several times, only the last value is used.

	 * 

	 * <p>

	 * If {@code null} value is set, it is like not setting a value at all. The

	 * property/default value configuration is applied.

	 * 

	 * @param interval

	 *            the time between two attempts

	 * @return this instance for fluent chaining

	 */

	public FixedIntervalBuilder<P> interval(Long interval) {

	}

	/**

	 * Set the interval between two executions (in milliseconds).

	 * 

	 * <p>

	 * This method is mainly used by {@link Configurer}s to register some

	 * property keys and/or a default value. The aim is to let developer be able

	 * to externalize its configuration (using system properties, configuration

	 * file or anything else). If the developer doesn't configure any value for

	 * the registered properties, the default value is used (if set).

	 * 

	 * <pre>

	 * .interval()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(10000L)

	 * </pre>

	 * 

	 * <p>

	 * Non-null value set using {@link #interval(Long)} takes precedence over

	 * property values and default value.

	 * 

	 * <pre>

	 * .interval(5000L)

	 * .interval()

	 *   .properties("${custom.property.high-priority}", "${custom.property.low-priority}")

	 *   .defaultValue(10000L)

	 * </pre>

	 * 

	 * The value {@code 5000L} is used regardless of the value of the properties

	 * and default value.

	 * 

	 * <p>

	 * See {@link ConfigurationValueBuilder} for more information.

	 * 

	 * 

	 * @return the builder to configure property keys/default value

	 */

	public ConfigurationValueBuilder<FixedIntervalBuilder<P>, Long> interval() {

	}

	@Override

	public RetryStrategy build() {

		}

	}

	private int buildMaxRetries() {

	}

	private long buildInterval() {

	}

}

Mutations