Added retry config to common module

Author: alex268

common/src/main/java/tech/ydb/common/retry/ErrorPolicy.java

@@ -7,11 +7,11 @@
  *
  * @author Aleksandr Gorshenin
  */
-public abstract class ExponentialBackoffRetry implements RetryPolicy {
+public class ExponentialBackoffRetry implements RetryPolicy {
     private final long backoffMs;
     private final int backoffCeiling;
 
-    protected ExponentialBackoffRetry(long backoffMs, int backoffCeiling) {
+    public ExponentialBackoffRetry(long backoffMs, int backoffCeiling) {
         this.backoffMs = backoffMs;
         this.backoffCeiling = backoffCeiling;
     }
@@ -22,6 +22,11 @@ protected long backoffTimeMillis(int retryNumber) {
         return delay + ThreadLocalRandom.current().nextLong(delay);
     }
 
+    @Override
+    public long nextRetryMs(int retryCount, long elapsedTimeMs) {
+        return backoffTimeMillis(retryCount);
+    }
+
     /**
      * Return current base of backoff delays
      * @return backoff base duration in milliseconds
@@ -37,4 +42,5 @@ public long getBackoffMillis() {
     public int getBackoffCeiling() {
         return backoffCeiling;
     }
+
 }

common/src/main/java/tech/ydb/common/retry/ExponentialBackoffRetry.java

@@ -0,0 +1,98 @@
+package tech.ydb.common.retry;
+
+import tech.ydb.core.StatusCode;
+import tech.ydb.core.UnexpectedResultException;
+
+/**
+ * Recipes should use the retry configuration to decide how to retry
+ * errors like unsuccessful {@link tech.ydb.core.StatusCode}.
+ *
+ * @author Aleksandr Gorshenin
+ */
+@FunctionalInterface
+public interface RetryConfig {
+
+    /**
+     * Returns retry policy for the given status code and {@code null} if that status code is not retryable
+     *
+     * @param code status code to check
+     * @return policy of retries or {@code null} if the status code is not retryable
+     */
+    RetryPolicy isStatusRetryable(StatusCode code);
+
+    /**
+     * Returns retry policy for the given exception and {@code null} if that exception is not retryable
+     *
+     * @param th exception to check
+     * @return policy of retries or {@code null} if the exception is not retryable
+     */
+    default RetryPolicy isThrowableRetryable(Throwable th) {
+        for (Throwable ex = th; ex != null; ex = ex.getCause()) {
+            if (ex instanceof UnexpectedResultException) {
+                return isStatusRetryable(((UnexpectedResultException) ex).getStatus().getCode());
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Retries a non idempotent operation forever with default exponential delay
+     * @return retry configuration object
+     */
+    static RetryConfig retryForever() {
+        return newConfig().retryForever();
+    }
+
+    /**
+     * Retries a non idempotent operation with default exponential until the specified elapsed milliseconds expire
+     * @param maxElapsedMs maximum timeout for retries
+     * @return retry configuration object
+     */
+    static RetryConfig retryUntilElapsed(long maxElapsedMs) {
+        return newConfig().retryUntilElapsed(maxElapsedMs);
+    }
+
+    /**
+     * Retries an idempotent operation forever with default exponential delay
+     * @return retry configuration object
+     */
+    static RetryConfig idempotentRetryForever() {
+        return newConfig().retryIdempotent(true).retryForever();
+    }
+
+    /**
+     * Retries an idempotent operation with default exponential until the specified elapsed milliseconds expire
+     * @param maxElapsedMs maximum timeout for retries
+     * @return retry configuration object
+     */
+    static RetryConfig idempotentRetryUntilElapsed(long maxElapsedMs) {
+        return newConfig().retryIdempotent(true).retryUntilElapsed(maxElapsedMs);
+    }
+
+    /**
+     * Disabled retries configuration. Any error is considered as non retryable
+     * @return retry configuration object
+     */
+    static RetryConfig noRetries() {
+        return (StatusCode code) -> null;
+    }
+
+    /**
+     * Create a new custom configuration of retries
+     * @return retry configuration builder
+     */
+    static Builder newConfig() {
+        return new YdbRetryBuilder();
+    }
+
+    interface Builder {
+        Builder retryIdempotent(boolean retry);
+        Builder retryNotFound(boolean retry);
+        Builder withSlowBackoff(long backoff, int ceiling);
+        Builder withFastBackoff(long backoff, int ceiling);
+
+        RetryConfig retryForever();
+        RetryConfig retryNTimes(int maxRetries);
+        RetryConfig retryUntilElapsed(long maxElapsedMs);
+    }
+}

common/src/main/java/tech/ydb/common/retry/RetryConfig.java

@@ -0,0 +1,69 @@
+package tech.ydb.common.retry;
+
+/**
+ *
+ * @author Aleksandr Gorshenin
+ */
+class YdbRetryBuilder implements RetryConfig.Builder {
+    private boolean idempotent = false;
+    private boolean retryNotFound = false;
+
+    private long fastBackoff = 5;
+    private int fastCeiling = 10;
+
+    private long slowBackoff = 500;
+    private int slowCeiling = 6;
+
+    @Override
+    public YdbRetryBuilder retryIdempotent(boolean retry) {
+        this.idempotent = retry;
+        return this;
+    }
+
+    @Override
+    public YdbRetryBuilder retryNotFound(boolean retry) {
+        this.retryNotFound = retry;
+        return this;
+    }
+
+    @Override
+    public YdbRetryBuilder withSlowBackoff(long backoff, int ceiling) {
+        this.slowBackoff = backoff;
+        this.slowCeiling = ceiling;
+        return this;
+    }
+
+    @Override
+    public YdbRetryBuilder withFastBackoff(long backoff, int ceiling) {
+        this.fastBackoff = backoff;
+        this.fastCeiling = ceiling;
+        return this;
+    }
+
+    @Override
+    public RetryConfig retryForever() {
+        return new YdbRetryConfig(idempotent, retryNotFound,
+                (int retryCount, long elapsedTimeMs) -> 0,
+                new ExponentialBackoffRetry(fastBackoff, fastCeiling),
+                new ExponentialBackoffRetry(slowBackoff, slowCeiling)
+        );
+    }
+
+    @Override
+    public RetryConfig retryNTimes(int maxRetries) {
+        return new YdbRetryConfig(idempotent, retryNotFound,
+                (int retryCount, long elapsedTimeMs) -> retryCount >= maxRetries ? -1 : 0,
+                new RetryNTimes(maxRetries, fastBackoff, fastCeiling),
+                new RetryNTimes(maxRetries, slowBackoff, slowCeiling)
+        );
+    }
+
+    @Override
+    public RetryConfig retryUntilElapsed(long maxElapsedMs) {
+        return new YdbRetryConfig(idempotent, retryNotFound,
+                (int retryCount, long elapsedTimeMs) -> elapsedTimeMs > maxElapsedMs ? -1 : 0,
+                new RetryUntilElapsed(maxElapsedMs, fastBackoff, fastCeiling),
+                new RetryUntilElapsed(maxElapsedMs, slowBackoff, slowCeiling)
+        );
+    }
+}

common/src/main/java/tech/ydb/common/retry/YdbRetryBuilder.java

@@ -0,0 +1,62 @@
+package tech.ydb.common.retry;
+
+import tech.ydb.core.StatusCode;
+
+/**
+ *
+ * @author Aleksandr Gorshenin
+ */
+class YdbRetryConfig implements RetryConfig {
+    private final boolean idempotent;
+    private final boolean retryNotFound;
+    private final RetryPolicy immediatelly;
+    private final RetryPolicy fast;
+    private final RetryPolicy slow;
+
+    YdbRetryConfig(boolean idempotent, boolean notFound, RetryPolicy immediatelly, RetryPolicy fast, RetryPolicy slow) {
+        this.idempotent = idempotent;
+        this.retryNotFound = notFound;
+        this.immediatelly = immediatelly;
+        this.fast = fast;
+        this.slow = slow;
+    }
+
+    @Override
+    public RetryPolicy isStatusRetryable(StatusCode code) {
+        if (code == null) {
+            return null;
+        }
+
+        switch (code) {
+            // Instant retry
+            case BAD_SESSION:
+            case SESSION_BUSY:
+                return immediatelly;
+
+            // Fast backoff
+            case ABORTED:
+            case UNDETERMINED:
+                return fast;
+
+            // Slow backoff
+            case OVERLOADED:
+            case CLIENT_RESOURCE_EXHAUSTED:
+                return slow;
+
+            // Conditionally retry
+            case CLIENT_CANCELLED:
+            case CLIENT_INTERNAL_ERROR:
+            case TRANSPORT_UNAVAILABLE:
+            case UNAVAILABLE:
+                return idempotent ? fast : null;
+
+            // Not found retry
+            case NOT_FOUND:
+                return retryNotFound ? fast : null;
+
+            // All other codes are not retryable
+            default:
+                return null;
+        }
+    }
+}