[FSSDK-11170] update: decision service methods for cmab

core-api/src/main/java/com/optimizely/ab/Optimizely.java

@@ -16,10 +16,10 @@
 package com.optimizely.ab;
 
 import com.optimizely.ab.annotations.VisibleForTesting;
-import com.optimizely.ab.bucketing.Bucketer;
-import com.optimizely.ab.bucketing.DecisionService;
-import com.optimizely.ab.bucketing.FeatureDecision;
-import com.optimizely.ab.bucketing.UserProfileService;
+import com.optimizely.ab.bucketing.*;
+import com.optimizely.ab.cmab.service.CmabCacheValue;
+import com.optimizely.ab.cmab.service.CmabService;
+import com.optimizely.ab.cmab.service.DefaultCmabService;
 import com.optimizely.ab.config.AtomicProjectConfigManager;
 import com.optimizely.ab.config.DatafileProjectConfig;
 import com.optimizely.ab.config.EventType;
@@ -45,6 +45,7 @@
 import com.optimizely.ab.event.internal.UserEvent;
 import com.optimizely.ab.event.internal.UserEventFactory;
 import com.optimizely.ab.event.internal.payload.EventBatch;
+import com.optimizely.ab.internal.DefaultLRUCache;
 import com.optimizely.ab.internal.NotificationRegistry;
 import com.optimizely.ab.notification.ActivateNotification;
 import com.optimizely.ab.notification.DecisionNotification;
@@ -62,19 +63,16 @@
 import com.optimizely.ab.optimizelyconfig.OptimizelyConfig;
 import com.optimizely.ab.optimizelyconfig.OptimizelyConfigManager;
 import com.optimizely.ab.optimizelyconfig.OptimizelyConfigService;
-import com.optimizely.ab.optimizelydecision.DecisionMessage;
-import com.optimizely.ab.optimizelydecision.DecisionReasons;
-import com.optimizely.ab.optimizelydecision.DecisionResponse;
-import com.optimizely.ab.optimizelydecision.DefaultDecisionReasons;
-import com.optimizely.ab.optimizelydecision.OptimizelyDecideOption;
-import com.optimizely.ab.optimizelydecision.OptimizelyDecision;
+import com.optimizely.ab.optimizelydecision.*;
 import com.optimizely.ab.optimizelyjson.OptimizelyJSON;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
+
 import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -84,6 +82,7 @@
 import java.util.Map;
 import java.util.concurrent.locks.ReentrantLock;
 
+import com.optimizely.ab.cmab.client.CmabClient;
 import static com.optimizely.ab.internal.SafetyUtils.tryClose;
 
 /**
@@ -141,8 +140,11 @@ public class Optimizely implements AutoCloseable {
     @Nullable
     private final ODPManager odpManager;
 
+    private final CmabService cmabService;
+
     private final ReentrantLock lock = new ReentrantLock();
 
+
     private Optimizely(@Nonnull EventHandler eventHandler,
                        @Nonnull EventProcessor eventProcessor,
                        @Nonnull ErrorHandler errorHandler,
@@ -152,8 +154,9 @@ private Optimizely(@Nonnull EventHandler eventHandler,
                        @Nullable OptimizelyConfigManager optimizelyConfigManager,
                        @Nonnull NotificationCenter notificationCenter,
                        @Nonnull List<OptimizelyDecideOption> defaultDecideOptions,
-                       @Nullable ODPManager odpManager
-    ) {
+                       @Nullable ODPManager odpManager,
+                       @Nonnull CmabService cmabService
+                       ) {
         this.eventHandler = eventHandler;
         this.eventProcessor = eventProcessor;
         this.errorHandler = errorHandler;
@@ -164,6 +167,7 @@ private Optimizely(@Nonnull EventHandler eventHandler,
         this.notificationCenter = notificationCenter;
         this.defaultDecideOptions = defaultDecideOptions;
         this.odpManager = odpManager;
+        this.cmabService = cmabService;
 
         if (odpManager != null) {
             odpManager.getEventManager().start();
@@ -1395,7 +1399,8 @@ Map<String, OptimizelyDecision> decideForKeys(@Nonnull OptimizelyUserContext use
     private Map<String, OptimizelyDecision> decideForKeys(@Nonnull OptimizelyUserContext user,
                                                           @Nonnull List<String> keys,
                                                           @Nonnull List<OptimizelyDecideOption> options,
-                                                          boolean ignoreDefaultOptions) {
+                                                          boolean ignoreDefaultOptions,
+                                                          DecisionPath decisionPath) {
         Map<String, OptimizelyDecision> decisionMap = new HashMap<>();
 
         ProjectConfig projectConfig = getProjectConfig();
@@ -1440,11 +1445,25 @@ private Map<String, OptimizelyDecision> decideForKeys(@Nonnull OptimizelyUserCon
         }
 
         List<DecisionResponse<FeatureDecision>> decisionList =
-            decisionService.getVariationsForFeatureList(flagsWithoutForcedDecision, user, projectConfig, allOptions);
+            decisionService.getVariationsForFeatureList(flagsWithoutForcedDecision, user, projectConfig, allOptions, decisionPath);
 
         for (int i = 0; i < flagsWithoutForcedDecision.size(); i++) {
             DecisionResponse<FeatureDecision> decision = decisionList.get(i);
+            boolean error = decision.isError();
+            String experimentKey = null;
+            if (decision.getResult() != null && decision.getResult().experiment != null) {
+                experimentKey = decision.getResult().experiment.getKey();
+            }
             String flagKey = flagsWithoutForcedDecision.get(i).getKey();
+
+            if (error) {
+                OptimizelyDecision optimizelyDecision = OptimizelyDecision.newErrorDecision(flagKey, user, DecisionMessage.CMAB_ERROR.reason(experimentKey));
+                decisionMap.put(flagKey, optimizelyDecision);
+                if (validKeys.contains(flagKey)) {
+                    validKeys.remove(flagKey);
+                }
+            }
+
             flagDecisions.put(flagKey, decision.getResult());
             decisionReasonsMap.get(flagKey).merge(decision.getReasons());
         }
@@ -1465,6 +1484,13 @@ private Map<String, OptimizelyDecision> decideForKeys(@Nonnull OptimizelyUserCon
         return decisionMap;
     }
 
+    private Map<String, OptimizelyDecision> decideForKeys(@Nonnull OptimizelyUserContext user,
+                                                          @Nonnull List<String> keys,
+                                                          @Nonnull List<OptimizelyDecideOption> options,
+                                                          boolean ignoreDefaultOptions) {
+        return decideForKeys(user, keys, options, ignoreDefaultOptions, DecisionPath.WITH_CMAB);
+    }
+
     Map<String, OptimizelyDecision> decideAll(@Nonnull OptimizelyUserContext user,
                                               @Nonnull List<OptimizelyDecideOption> options) {
         Map<String, OptimizelyDecision> decisionMap = new HashMap<>();
@@ -1482,6 +1508,125 @@ Map<String, OptimizelyDecision> decideAll(@Nonnull OptimizelyUserContext user,
         return decideForKeys(user, allFlagKeys, options);
     }
 
+    /**
+     * Returns a decision result ({@link OptimizelyDecision}) for a given flag key and a user context,
+     * skipping CMAB logic and using only traditional A/B testing.
+     * This will be called by mobile apps which will make synchronous decisions only (for backward compatibility with android-sdk)
+     *
+     * @param user    An OptimizelyUserContext associated with this OptimizelyClient.
+     * @param key     A flag key for which a decision will be made.
+     * @param options A list of options for decision-making.
+     * @return A decision result using traditional A/B testing logic only.
+     */
+    OptimizelyDecision decideSync(@Nonnull OptimizelyUserContext user,
+                                  @Nonnull String key,
+                                  @Nonnull List<OptimizelyDecideOption> options) {
+        ProjectConfig projectConfig = getProjectConfig();
+        if (projectConfig == null) {
+            return OptimizelyDecision.newErrorDecision(key, user, DecisionMessage.SDK_NOT_READY.reason());
+        }
+
+        List<OptimizelyDecideOption> allOptions = getAllOptions(options);
+        allOptions.remove(OptimizelyDecideOption.ENABLED_FLAGS_ONLY);
+
+        return decideForKeysSync(user, Arrays.asList(key), allOptions, true).get(key);
+    }
+
+    /**
+     * Returns decision results for multiple flag keys, skipping CMAB logic and using only traditional A/B testing.
+     * This will be called by mobile apps which will make synchronous decisions only (for backward compatibility with android-sdk)
+     *
+     * @param user    An OptimizelyUserContext associated with this OptimizelyClient.
+     * @param keys    A list of flag keys for which decisions will be made.
+     * @param options A list of options for decision-making.
+     * @return All decision results mapped by flag keys, using traditional A/B testing logic only.
+     */
+    Map<String, OptimizelyDecision> decideForKeysSync(@Nonnull OptimizelyUserContext user,
+                                                      @Nonnull List<String> keys,
+                                                      @Nonnull List<OptimizelyDecideOption> options) {
+        return decideForKeysSync(user, keys, options, false);
+    }
+
+    /**
+     * Returns decision results for all active flag keys, skipping CMAB logic and using only traditional A/B testing.
+     * This will be called by mobile apps which will make synchronous decisions only (for backward compatibility with android-sdk)
+     *
+     * @param user    An OptimizelyUserContext associated with this OptimizelyClient.
+     * @param options A list of options for decision-making.
+     * @return All decision results mapped by flag keys, using traditional A/B testing logic only.
+     */
+    Map<String, OptimizelyDecision> decideAllSync(@Nonnull OptimizelyUserContext user,
+                                                  @Nonnull List<OptimizelyDecideOption> options) {
+        Map<String, OptimizelyDecision> decisionMap = new HashMap<>();
+
+        ProjectConfig projectConfig = getProjectConfig();
+        if (projectConfig == null) {
+            logger.error("Optimizely instance is not valid, failing decideAllSync call.");
+            return decisionMap;
+        }
+
+        List<FeatureFlag> allFlags = projectConfig.getFeatureFlags();
+        List<String> allFlagKeys = new ArrayList<>();
+        for (int i = 0; i < allFlags.size(); i++) allFlagKeys.add(allFlags.get(i).getKey());
+
+        return decideForKeysSync(user, allFlagKeys, options);
+    }
+
+    private Map<String, OptimizelyDecision> decideForKeysSync(@Nonnull OptimizelyUserContext user,
+                                                              @Nonnull List<String> keys,
+                                                              @Nonnull List<OptimizelyDecideOption> options,
+                                                              boolean ignoreDefaultOptions) {
+        return decideForKeys(user, keys, options, ignoreDefaultOptions, DecisionPath.WITHOUT_CMAB);
+    }
+
+    //============ decide async ============//
+
+    /**
+     * Returns a decision result asynchronously for a given flag key and a user context.
+     *
+     * @param userContext The user context to make decisions for
+     * @param key A flag key for which a decision will be made
+     * @param callback A callback to invoke when the decision is available
+     * @param options A list of options for decision-making
+     */
+    public void decideAsync(@Nonnull OptimizelyUserContext userContext,
+                            @Nonnull String key,
+                            @Nonnull OptimizelyDecisionCallback callback,
+                            @Nonnull List<OptimizelyDecideOption> options) {
+        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(userContext, key, options, callback);
+        fetcher.start();
+    }
+
+    /**
+     * Returns decision results asynchronously for multiple flag keys.
+     *
+     * @param userContext The user context to make decisions for
+     * @param keys        A list of flag keys for which decisions will be made
+     * @param callback    A callback to invoke when decisions are available
+     * @param options     A list of options for decision-making
+     */
+    public void decideForKeysAsync(@Nonnull OptimizelyUserContext userContext,
+                                   @Nonnull List<String> keys,
+                                   @Nonnull OptimizelyDecisionsCallback callback,
+                                   @Nonnull List<OptimizelyDecideOption> options) {
+        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(userContext, keys, options, callback);
+        fetcher.start();
+    }
+
+    /**
+     * Returns decision results asynchronously for all active flag keys.
+     *
+     * @param userContext The user context to make decisions for
+     * @param callback A callback to invoke when decisions are available
+     * @param options A list of options for decision-making
+     */
+    public void decideAllAsync(@Nonnull OptimizelyUserContext userContext,
+                               @Nonnull OptimizelyDecisionsCallback callback,
+                               @Nonnull List<OptimizelyDecideOption> options) {
+        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(userContext, options, callback);
+        fetcher.start();
+    }
+
     private List<OptimizelyDecideOption> getAllOptions(List<OptimizelyDecideOption> options) {
         List<OptimizelyDecideOption> copiedOptions = new ArrayList(defaultDecideOptions);
         if (options != null) {
@@ -1731,6 +1876,7 @@ public static class Builder {
         private NotificationCenter notificationCenter;
         private List<OptimizelyDecideOption> defaultDecideOptions;
         private ODPManager odpManager;
+        private CmabService cmabService;
 
         // For backwards compatibility
         private AtomicProjectConfigManager fallbackConfigManager = new AtomicProjectConfigManager();
@@ -1842,6 +1988,11 @@ public Builder withODPManager(ODPManager odpManager) {
             return this;
         }
 
+        public Builder withCmabService(CmabService cmabService) {
+            this.cmabService = cmabService;
+            return this;
+        }
+
         // Helper functions for making testing easier
         protected Builder withBucketing(Bucketer bucketer) {
             this.bucketer = bucketer;
@@ -1872,8 +2023,12 @@ public Optimizely build() {
                 bucketer = new Bucketer();
             }
 
+            if (cmabService == null) {
+                logger.warn("CMAB service is not initiated. CMAB functionality will not be available.");
+            }
+
             if (decisionService == null) {
-                decisionService = new DecisionService(bucketer, errorHandler, userProfileService);
+                decisionService = new DecisionService(bucketer, errorHandler, userProfileService, cmabService);
             }
 
             if (projectConfig == null && datafile != null && !datafile.isEmpty()) {
@@ -1916,7 +2071,7 @@ public Optimizely build() {
                 defaultDecideOptions = Collections.emptyList();
             }
 
-            return new Optimizely(eventHandler, eventProcessor, errorHandler, decisionService, userProfileService, projectConfigManager, optimizelyConfigManager, notificationCenter, defaultDecideOptions, odpManager);
+            return new Optimizely(eventHandler, eventProcessor, errorHandler, decisionService, userProfileService, projectConfigManager, optimizelyConfigManager, notificationCenter, defaultDecideOptions, odpManager, cmabService);
         }
     }
 }

core-api/src/main/java/com/optimizely/ab/OptimizelyUserContext.java

@@ -16,18 +16,23 @@
  */
 package com.optimizely.ab;
 
-import com.optimizely.ab.config.ProjectConfig;
-import com.optimizely.ab.odp.ODPManager;
-import com.optimizely.ab.odp.ODPSegmentCallback;
-import com.optimizely.ab.odp.ODPSegmentOption;
-import com.optimizely.ab.optimizelydecision.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.optimizely.ab.odp.ODPSegmentCallback;
+import com.optimizely.ab.odp.ODPSegmentOption;
+import com.optimizely.ab.optimizelydecision.OptimizelyDecideOption;
+import com.optimizely.ab.optimizelydecision.OptimizelyDecision;
 
 public class OptimizelyUserContext {
     // OptimizelyForcedDecisionsKey mapped to variationKeys
@@ -42,7 +47,7 @@ public class OptimizelyUserContext {
     private List<String> qualifiedSegments;
 
     @Nonnull
-    private final Optimizely optimizely;
+    final Optimizely optimizely;
 
     private static final Logger logger = LoggerFactory.getLogger(OptimizelyUserContext.class);