add: implement CmabClient, CmabClientConfig, and RetryConfig with fetchDecision method and retry logic

Author: FarhanAnjum-opti

core-api/src/main/java/com/optimizely/ab/cmab/CmabClient.java

@@ -0,0 +1,17 @@
+package com.optimizely.ab.cmab;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+public interface CmabClient {
+    /**
+     * Fetches a decision from the CMAB prediction service.
+     *
+     * @param ruleId     The rule/experiment ID
+     * @param userId     The user ID
+     * @param attributes User attributes
+     * @param cmabUuid   The CMAB UUID
+     * @return CompletableFuture containing the variation ID as a String
+     */
+    CompletableFuture<String> fetchDecision(String ruleId, String userId, Map<String, Object> attributes, String cmabUuid);
+}

core-api/src/main/java/com/optimizely/ab/cmab/CmabClientConfig.java

@@ -0,0 +1,34 @@
+package com.optimizely.ab.cmab;
+
+import javax.annotation.Nullable;
+
+/**
+ * Configuration for CMAB client operations.
+ * Contains only retry configuration since HTTP client is handled separately.
+ */
+public class CmabClientConfig {
+    private final RetryConfig retryConfig;
+
+    public CmabClientConfig(@Nullable RetryConfig retryConfig) {
+        this.retryConfig = retryConfig;
+    }
+
+    @Nullable
+    public RetryConfig getRetryConfig() {
+        return retryConfig;
+    }
+
+    /**
+     * Creates a config with default retry settings.
+     */
+    public static CmabClientConfig withDefaultRetry() {
+        return new CmabClientConfig(RetryConfig.defaultConfig());
+    }
+
+    /**
+     * Creates a config with no retry.
+     */
+    public static CmabClientConfig withNoRetry() {
+        return new CmabClientConfig(null);
+    }
+}

core-api/src/main/java/com/optimizely/ab/cmab/RetryConfig.java

@@ -0,0 +1,105 @@
+package com.optimizely.ab.cmab;
+/**
+ * Configuration for retry behavior in CMAB client operations.
+ */
+public class RetryConfig {
+    private final int maxRetries;
+    private final long backoffBaseMs;
+    private final double backoffMultiplier;
+
+    /**
+     * Creates a RetryConfig with custom retry and backoff settings.
+     *
+     * @param maxRetries         Maximum number of retry attempts
+     * @param backoffBaseMs      Base delay in milliseconds for the first retry
+     * @param backoffMultiplier  Multiplier for exponential backoff (e.g., 2.0 for doubling)
+     */
+    public RetryConfig(int maxRetries, long backoffBaseMs, double backoffMultiplier) {
+        if (maxRetries < 0) {
+            throw new IllegalArgumentException("maxRetries cannot be negative");
+        }
+        if (backoffBaseMs < 0) {
+            throw new IllegalArgumentException("backoffBaseMs cannot be negative");
+        }
+        if (backoffMultiplier < 1.0) {
+            throw new IllegalArgumentException("backoffMultiplier must be >= 1.0");
+        }
+
+        this.maxRetries = maxRetries;
+        this.backoffBaseMs = backoffBaseMs;
+        this.backoffMultiplier = backoffMultiplier;
+    }
+
+    /**
+     * Creates a RetryConfig with default backoff settings (1 second base, 2x multiplier).
+     *
+     * @param maxRetries Maximum number of retry attempts
+     */
+    public RetryConfig(int maxRetries) {
+        this(maxRetries, 1000, 2.0); // Default: 1 second base, exponential backoff
+    }
+
+    /**
+     * Creates a default RetryConfig with 3 retries and exponential backoff.
+     */
+    public static RetryConfig defaultConfig() {
+        return new RetryConfig(3);
+    }
+
+    /**
+     * Creates a RetryConfig with no retries (single attempt only).
+     */
+    public static RetryConfig noRetry() {
+        return new RetryConfig(0);
+    }
+
+    public int getMaxRetries() {
+        return maxRetries;
+    }
+
+    public long getBackoffBaseMs() {
+        return backoffBaseMs;
+    }
+
+    public double getBackoffMultiplier() {
+        return backoffMultiplier;
+    }
+
+    /**
+     * Calculates the delay for a specific retry attempt.
+     *
+     * @param attemptNumber The attempt number (0-based, so 0 = first retry)
+     * @return Delay in milliseconds
+     */
+    public long calculateDelay(int attemptNumber) {
+        if (attemptNumber < 0) {
+            return 0;
+        }
+        return (long) (backoffBaseMs * Math.pow(backoffMultiplier, attemptNumber));
+    }
+
+    @Override
+    public String toString() {
+        return String.format("RetryConfig{maxRetries=%d, backoffBaseMs=%d, backoffMultiplier=%.1f}",
+            maxRetries, backoffBaseMs, backoffMultiplier);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+
+        RetryConfig that = (RetryConfig) obj;
+        return maxRetries == that.maxRetries &&
+            backoffBaseMs == that.backoffBaseMs &&
+            Double.compare(that.backoffMultiplier, backoffMultiplier) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = maxRetries;
+        result = 31 * result + Long.hashCode(backoffBaseMs);
+        result = 31 * result + Double.hashCode(backoffMultiplier);
+        return result;
+    }
+}