Retry

O java-restify oferece suporte para retry de requisições, síncronas ou assíncronas.

Por padrão, o suporte para retry é desabilitado, e deve ser explicitamente habilitado.

MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
    .target(MyApi.class)
        .build();

Configuração

As configurações podem ser realizadas no próprio builder, e serão aplicadas para todos os métodos da interface:

MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .configure()
            .attempts(3) // número de tentativas (padrão: 1 (sem retry))
            .timeout(Duration.ofMillis(10000)) // timeout máximo para as tentativas, pode ser informado também em milisegundos (opcional)
            .backOff() // configuração de backoff
                .delay(Duration.ofMillis(2000)) // período entre cada tentiva, pode ser informado também em milisegundos (padrão é 1000 milisegundos, aplicável apenas se attempts > 1)
                .multiplier(1.5) // fator de multiplicação de tempo entre cada tentativa (padrão é 1, sem efeito prático)
                .and()
            .when(IOException.class)
            .when(HttpStatusCode.INTERNAL_SERVER_ERROR, HttpStatusCode.BAD_GATEWAY)
    .target(MyApi.class)
        .build();

Outra configuração necessária é o tipo de situação onde o retry deve ser executado. Novamente, o comportamento padrão é não aplicar nenhum tipo de retentativa, a não ser para os cenários explicitamente configurados:

MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .configure()
            // ... outras configurações que serão aplicadas quando...
            .when(IOException.class) // ocorrerem exceções do tipo IOException
            .when(HttpStatusCode.INTERNAL_SERVER_ERROR, HttpStatusCode.BAD_GATEWAY) // respostas HTTP com esses status codes
    .target(MyApi.class)
        .build();

É possível configurar vários cenários de erro usando do método when, quantos forem necessários. Existem outras sobrecargas que permitem ajustes ainda mais finos:

import com.github.ljtfreitas.restify.http.client.retry.RetryCondition.EndpointResponseRetryCondition;

// condição de retry utilizando uma instância de EndpointResponse
EndpointResponseRetryCondition condition = response -> response.body().equals("fail") && response.headers().get("X-Fail").isPresent();

MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .configure()
            // ... outras configurações que serão aplicadas quando...
            .when(condition) // a condição for satisfeita
    .target(MyApi.class)
        .build();

import com.github.ljtfreitas.restify.http.client.retry.RetryCondition.HeadersRetryCondition;

// condição de retry utilizando a coleção de headers da resposta
HeadersRetryCondition condition = headers -> headers.get("X-Should-Retry").isPresent();

/* shortcuts:

    condition = HeadersRetryCondition.contains("X-Should-Retry");

    condition = HeadersRetryCondition.contains(Header.of("X-Should-Retry", "true")); // para verificar também o valor do header
*/

MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .configure()
            // ... outras configurações que serão aplicadas quando...
            .when(condition) // a condição for satisfeita
    .target(MyApi.class)
        .build();

import com.github.ljtfreitas.restify.http.client.retry.RetryCondition.StatusCodeRetryCondition;

// condição de retry utilizando o status code da resposta
StatusCodeRetryCondition condition =  status -> status.isInternalServerError();

/* shortcuts:

    condition = StatusCodeRetryCondition.any(HttpStatusCode.INTERNAL_SERVER_ERROR, HttpStatusCode.BAD_GATEWAY);

    condition = StatusCodeRetryCondition.any4xx();

    condition = StatusCodeRetryCondition.any5xx();
*/
MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .configure()
            // ... outras configurações que serão aplicadas quando...
            .when(condition) // a condição for satisfeita
    .target(MyApi.class)
        .build();

import com.github.ljtfreitas.restify.http.client.retry.RetryCondition.ThrowableRetryCondition;

// condição de retry utilizando a exceção
ThrowableRetryCondition condition =  e -> (e instanceof IOException);

/* shortcuts:

    condition = ThrowableRetryCondition.any(IOException.class);

    condition = ThrowableRetryCondition.ioFailure();
*/
MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .configure()
            // ... outras configurações que serão aplicadas quando...
            .when(condition) // a condição for satisfeita
    .target(MyApi.class)
        .build();

@Retry

Também é possível aplicar configurações mais específicas no nível do método, usando a anotação @Retry. Essa anotação tem parâmetros equivalentes às configurações disponíveis no RestifyProxyBuilder.

Essa anotação só é lida e processada se o retry for habilitado, conforme demonstrado acima.

public interface MyApi {

    @Path("/customers/{id}") @Get
    @Retry(
        attempts = 3, // número de tentativas (padrão: 1 (sem retry))
        timeout = 10000, // timeout máximo para as tentativas em milisegundos (opcional)
        on4xxStatus = true, // retry para status codes 4xx (padrão false)
        on5xxStatus = true, // retry para status codes 5xx (padrão false)
        onIOFailure = true, // retry para erros do tipo IOException (padrão false)
        status = {HttpStatusCode.INTERNAL_SERVER_ERROR, HttpStatusCode.BAD_GATEWAY}, // lista de status codes para retry (padrão é nenhum)
        exceptions = SocketException.class, // lista de exceções para retry (padrão é nenhuma)
        backoff = @BackOff( // configurações de backoff
                    delay = 2000, // período entre cada tentativa, em milisegundos (padrão é 1000 milisegundos, aplicável apenas se attempts > 1)
                    multiplier = 1.5 // fator de multiplicação de tempo entre cada tentativa (padrão é 1, sem efeito prático)
                )
        )
    Customer findCustomer(@PathParameter String id);

Se a anotação @Retry estiver presente no topo da interface, a configuração será aplicada a todos os métodos.

Requisiçoes assíncronas

Todas as configurações demonstradas acima também se aplicam para requições assíncronas. A implementação padrão utiliza um ScheduledExecutorService, criado com uma configuração single-thread.

Caso essa configuração não atenda as necessidades da sua aplicação, é bastante simples configurar um novo ScheduledExecutorService:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public interface MyApi {

    // CompletableFuture = requisição assíncrona
    // as retentativas também serão executas em thread separadas

    @Path("/customers/{id}") @Get
    @Retry(attempts = 3, on5xxStatus = true, backoff = @BackOff(delay = 2000))
    CompletableFuture<Customer> findCustomer(@PathParameter String id); 
}

ScheduledExecutorService myScheduler = Executors.newScheduledThreadPool(10);

MyApi myApi = new RestifyProxyBuilder()
    .retry()
        .enabled()
        .async()
            .scheduler(myScheduler)
    .target(MyApi.class)
        .build();