SyncHelper with RBS storage

src/main/java/io/split/android/client/SplitFactoryHelper.java

@@ -86,8 +86,6 @@
 import io.split.android.client.storage.events.PersistentEventsStorage;
 import io.split.android.client.storage.general.GeneralInfoStorage;
 import io.split.android.client.storage.impressions.PersistentImpressionsStorage;
-import io.split.android.client.storage.rbs.RuleBasedSegmentStorage;
-import io.split.android.client.storage.rbs.RuleBasedSegmentStorageImpl;
 import io.split.android.client.storage.splits.SplitsStorage;
 import io.split.android.client.telemetry.TelemetrySynchronizer;
 import io.split.android.client.telemetry.TelemetrySynchronizerImpl;
@@ -96,8 +94,6 @@
 import io.split.android.client.telemetry.storage.TelemetryStorage;
 import io.split.android.client.utils.Utils;
 import io.split.android.client.utils.logger.Logger;
-import io.split.android.engine.experiments.ParserCommons;
-import io.split.android.engine.experiments.RuleBasedSegmentParser;
 
 class SplitFactoryHelper {
     private static final int DB_MAGIC_CHARS_COUNT = 4;
@@ -469,22 +465,6 @@ ExecutorService getImpressionsLoggingTaskExecutor() {
                 new ThreadPoolExecutor.CallerRunsPolicy());
     }
 
-    @NonNull
-    static ParserCommons getParserCommons(SplitStorageContainer storageContainer) {
-        ParserCommons parserCommons = new ParserCommons(
-                storageContainer.getMySegmentsStorageContainer(),
-                storageContainer.getMyLargeSegmentsStorageContainer());
-
-        RuleBasedSegmentParser ruleBasedSegmentParser = new RuleBasedSegmentParser(parserCommons);
-
-        RuleBasedSegmentStorage ruleBasedSegmentStorage =
-                new RuleBasedSegmentStorageImpl(storageContainer.getPersistentRuleBasedSegmentStorage(), ruleBasedSegmentParser);
-
-        parserCommons.setRuleBasedSegmentStorage(ruleBasedSegmentStorage);
-
-        return parserCommons;
-    }
-
     private TelemetryStorage getTelemetryStorage(boolean shouldRecordTelemetry, TelemetryStorage telemetryStorage) {
         if (telemetryStorage != null) {
             return telemetryStorage;

src/main/java/io/split/android/client/SplitFactoryImpl.java

@@ -71,7 +71,6 @@
 import io.split.android.client.validators.ValidationErrorInfo;
 import io.split.android.client.validators.ValidationMessageLogger;
 import io.split.android.client.validators.ValidationMessageLoggerImpl;
-import io.split.android.engine.experiments.ParserCommons;
 import io.split.android.engine.experiments.SplitParser;
 
 public class SplitFactoryImpl implements SplitFactory {
@@ -274,10 +273,7 @@ private SplitFactoryImpl(@NonNull String apiToken, @NonNull Key key, @NonNull Sp
                 streamingComponents.getNotificationProcessor(), streamingComponents.getSseAuthenticator(),
                 mStorageContainer, mSyncManager, compressionProvider);
 
-        ParserCommons parserCommons = SplitFactoryHelper.getParserCommons(mStorageContainer);
-
-        // Create SplitParser with ParserCommons
-        SplitParser splitParser = new SplitParser(parserCommons);
+        SplitParser splitParser = new SplitParser(mStorageContainer.getParserCommons());
 
         mClientContainer = new SplitClientContainerImpl(
                 mDefaultClientKey.matchingKey(), this, config, mSyncManager,

src/main/java/io/split/android/client/dtos/RuleBasedSegmentChange.java

@@ -32,10 +32,15 @@ public List<RuleBasedSegment> getSegments() {
 
     @VisibleForTesting
     public static RuleBasedSegmentChange createEmpty() {
+        return create(-1, -1, new ArrayList<>());
+    }
+
+    @VisibleForTesting
+    public static RuleBasedSegmentChange create(long since, long till, List<RuleBasedSegment> segments) {
         RuleBasedSegmentChange ruleBasedSegmentChange = new RuleBasedSegmentChange();
-        ruleBasedSegmentChange.segments = new ArrayList<>();
-        ruleBasedSegmentChange.since = -1;
-        ruleBasedSegmentChange.till = -1;
+        ruleBasedSegmentChange.segments = segments;
+        ruleBasedSegmentChange.since = since;
+        ruleBasedSegmentChange.till = till;
         return ruleBasedSegmentChange;
     }
 }

src/main/java/io/split/android/client/dtos/SplitChange.java

@@ -1,9 +1,20 @@
 package io.split.android.client.dtos;
 
+import androidx.annotation.VisibleForTesting;
+
 import java.util.List;
 
 public class SplitChange {
     public List<Split> splits;
     public long since;
     public long till;
+
+    @VisibleForTesting
+    public static SplitChange create(long since, long till, List<Split> splits) {
+        SplitChange splitChange = new SplitChange();
+        splitChange.since = since;
+        splitChange.till = till;
+        splitChange.splits = splits;
+        return splitChange;
+    }
 }

src/main/java/io/split/android/client/dtos/TargetingRulesChange.java

@@ -21,9 +21,14 @@ public RuleBasedSegmentChange getRuleBasedSegmentsChange() {
 
     @VisibleForTesting
     public static TargetingRulesChange create(SplitChange splitChange) {
+        return create(splitChange, RuleBasedSegmentChange.createEmpty());
+    }
+
+    @VisibleForTesting
+    public static TargetingRulesChange create(SplitChange splitChange, RuleBasedSegmentChange ruleBasedSegmentChange) {
         TargetingRulesChange targetingRulesChange = new TargetingRulesChange();
         targetingRulesChange.ff = splitChange;
-        targetingRulesChange.rbs = new RuleBasedSegmentChange();
+        targetingRulesChange.rbs = ruleBasedSegmentChange;
         return targetingRulesChange;
     }
 }

src/main/java/io/split/android/client/service/executor/SplitTaskFactoryImpl.java

@@ -48,6 +48,7 @@
 import io.split.android.client.storage.cipher.SplitCipher;
 import io.split.android.client.storage.common.SplitStorageContainer;
 import io.split.android.client.storage.db.SplitRoomDatabase;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorageProducer;
 import io.split.android.client.telemetry.storage.TelemetryRuntimeProducer;
 import io.split.android.client.telemetry.storage.TelemetryStorage;
 
@@ -83,20 +84,23 @@ public SplitTaskFactoryImpl(@NonNull SplitClientConfig splitClientConfig,
         mFlagsSpecFromConfig = flagsSpecFromConfig;
         mEventsManager = eventsManager;
         mSplitChangeProcessor = new SplitChangeProcessor(filters, flagSetsFilter);
+        RuleBasedSegmentStorageProducer ruleBasedSegmentStorageProducer = mSplitsStorageContainer.getRuleBasedSegmentStorage();
 
         TelemetryStorage telemetryStorage = mSplitsStorageContainer.getTelemetryStorage();
         mTelemetryRuntimeProducer = telemetryStorage;
         if (testingConfig != null) {
             mSplitsSyncHelper = new SplitsSyncHelper(mSplitApiFacade.getSplitFetcher(),
                     mSplitsStorageContainer.getSplitsStorage(),
                     mSplitChangeProcessor,
+                    ruleBasedSegmentStorageProducer,
                     mTelemetryRuntimeProducer,
                     new ReconnectBackoffCounter(1, testingConfig.getCdnBackoffTime()),
                     flagsSpecFromConfig);
         } else {
             mSplitsSyncHelper = new SplitsSyncHelper(mSplitApiFacade.getSplitFetcher(),
                     mSplitsStorageContainer.getSplitsStorage(),
                     mSplitChangeProcessor,
+                    ruleBasedSegmentStorageProducer,
                     mTelemetryRuntimeProducer,
                     flagsSpecFromConfig);
         }

src/main/java/io/split/android/client/service/splits/SplitsSyncHelper.java

@@ -8,11 +8,16 @@
 import androidx.annotation.VisibleForTesting;
 
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
+import io.split.android.client.dtos.RuleBasedSegment;
+import io.split.android.client.dtos.RuleBasedSegmentChange;
 import io.split.android.client.dtos.SplitChange;
+import io.split.android.client.dtos.Status;
 import io.split.android.client.dtos.TargetingRulesChange;
 import io.split.android.client.network.SplitHttpHeadersBuilder;
 import io.split.android.client.service.ServiceConstants;
@@ -23,6 +28,7 @@
 import io.split.android.client.service.http.HttpStatus;
 import io.split.android.client.service.sseclient.BackoffCounter;
 import io.split.android.client.service.sseclient.ReconnectBackoffCounter;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorageProducer;
 import io.split.android.client.storage.splits.SplitsStorage;
 import io.split.android.client.telemetry.model.OperationType;
 import io.split.android.client.telemetry.storage.TelemetryRuntimeProducer;
@@ -37,18 +43,21 @@ public class SplitsSyncHelper {
     private final HttpFetcher<TargetingRulesChange> mSplitFetcher;
     private final SplitsStorage mSplitsStorage;
     private final SplitChangeProcessor mSplitChangeProcessor;
+    private final RuleBasedSegmentStorageProducer mRuleBasedSegmentStorage;
     private final TelemetryRuntimeProducer mTelemetryRuntimeProducer;
     private final BackoffCounter mBackoffCounter;
     private final String mFlagsSpec;
 
     public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
                             @NonNull SplitsStorage splitsStorage,
                             @NonNull SplitChangeProcessor splitChangeProcessor,
+                            @NonNull RuleBasedSegmentStorageProducer ruleBasedSegmentStorage,
                             @NonNull TelemetryRuntimeProducer telemetryRuntimeProducer,
                             @Nullable String flagsSpec) {
         this(splitFetcher,
                 splitsStorage,
                 splitChangeProcessor,
+                ruleBasedSegmentStorage,
                 telemetryRuntimeProducer,
                 new ReconnectBackoffCounter(1, ON_DEMAND_FETCH_BACKOFF_MAX_WAIT),
                 flagsSpec);
@@ -58,12 +67,14 @@ public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
     public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
                             @NonNull SplitsStorage splitsStorage,
                             @NonNull SplitChangeProcessor splitChangeProcessor,
+                            @NonNull RuleBasedSegmentStorageProducer ruleBasedSegmentStorage,
                             @NonNull TelemetryRuntimeProducer telemetryRuntimeProducer,
                             @NonNull BackoffCounter backoffCounter,
                             @Nullable String flagsSpec) {
         mSplitFetcher = checkNotNull(splitFetcher);
         mSplitsStorage = checkNotNull(splitsStorage);
         mSplitChangeProcessor = checkNotNull(splitChangeProcessor);
+        mRuleBasedSegmentStorage = checkNotNull(ruleBasedSegmentStorage);
         mTelemetryRuntimeProducer = checkNotNull(telemetryRuntimeProducer);
         mBackoffCounter = checkNotNull(backoffCounter);
         mFlagsSpec = flagsSpec;
@@ -155,8 +166,9 @@ private long fetchUntil(long till, boolean clearBeforeUpdate, boolean avoidCache
             }
 
             TargetingRulesChange targetingRulesChange = fetchSplits(changeNumber, avoidCache, withCdnByPass);
-            SplitChange splitChange = targetingRulesChange.getFeatureFlagsChange(); // TODO
-            updateStorage(shouldClearBeforeUpdate, splitChange);
+            SplitChange splitChange = targetingRulesChange.getFeatureFlagsChange();
+            RuleBasedSegmentChange ruleBasedSegmentChange = targetingRulesChange.getRuleBasedSegmentsChange();
+            updateStorage(shouldClearBeforeUpdate, splitChange, ruleBasedSegmentChange);
             shouldClearBeforeUpdate = false;
 
             newTill = splitChange.till;
@@ -180,11 +192,27 @@ private TargetingRulesChange fetchSplits(long till, boolean avoidCache, boolean
         return mSplitFetcher.execute(params, getHeaders(avoidCache));
     }
 
-    private void updateStorage(boolean clearBeforeUpdate, SplitChange splitChange) {
+    private void updateStorage(boolean clearBeforeUpdate, SplitChange splitChange, RuleBasedSegmentChange ruleBasedSegmentChange) {
         if (clearBeforeUpdate) {
             mSplitsStorage.clear();
+            mRuleBasedSegmentStorage.clear();
         }
         mSplitsStorage.update(mSplitChangeProcessor.process(splitChange));
+        updateRbsStorage(ruleBasedSegmentChange);
+    }
+
+    private void updateRbsStorage(RuleBasedSegmentChange ruleBasedSegmentChange) {
+        long changeNumber = ruleBasedSegmentChange.getTill();
+        Set<RuleBasedSegment> toAdd = new HashSet<>();
+        Set<RuleBasedSegment> toRemove = new HashSet<>();
+        for (RuleBasedSegment segment : ruleBasedSegmentChange.getSegments()) {
+            if (segment.getStatus() == Status.ACTIVE) {
+                toAdd.add(segment);
+            } else {
+                toRemove.add(segment);
+            }
+        }
+        mRuleBasedSegmentStorage.update(toAdd, toRemove, changeNumber);
     }
 
     private void logError(String message) {

src/main/java/io/split/android/client/service/workmanager/splits/SplitsSyncWorkerTaskBuilder.java

@@ -6,6 +6,7 @@
 import io.split.android.client.service.splits.SplitChangeProcessor;
 import io.split.android.client.service.splits.SplitsSyncHelper;
 import io.split.android.client.service.splits.SplitsSyncTask;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorageProducer;
 import io.split.android.client.storage.splits.SplitsStorage;
 import io.split.android.client.telemetry.storage.TelemetryStorage;
 import io.split.android.client.utils.logger.Logger;
@@ -37,12 +38,14 @@ SplitTask getTask() {
         try {
             SplitsStorage splitsStorage = mStorageProvider.provideSplitsStorage();
             TelemetryStorage telemetryStorage = mStorageProvider.provideTelemetryStorage();
+            RuleBasedSegmentStorageProducer ruleBasedSegmentStorageProducer = mStorageProvider.provideRuleBasedSegmentStorage();
             String splitsFilterQueryString = splitsStorage.getSplitsFilterQueryString();
 
             SplitsSyncHelper splitsSyncHelper = mSplitsSyncHelperProvider.provideSplitsSyncHelper(
                     mFetcherProvider.provideFetcher(splitsFilterQueryString),
                     splitsStorage,
                     mSplitChangeProcessor,
+                    ruleBasedSegmentStorageProducer,
                     telemetryStorage,
                     mFlagsSpec);
 

src/main/java/io/split/android/client/service/workmanager/splits/StorageProvider.java

@@ -1,26 +1,27 @@
 package io.split.android.client.service.workmanager.splits;
 
+import io.split.android.client.storage.cipher.SplitCipher;
+import io.split.android.client.storage.cipher.SplitCipherFactory;
 import io.split.android.client.storage.db.SplitRoomDatabase;
 import io.split.android.client.storage.db.StorageFactory;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorageProducer;
 import io.split.android.client.storage.splits.SplitsStorage;
 import io.split.android.client.telemetry.storage.TelemetryStorage;
 
 class StorageProvider {
 
     private final SplitRoomDatabase mDatabase;
-    private final String mApiKey;
-    private final boolean mEncryptionEnabled;
     private final boolean mShouldRecordTelemetry;
+    private final SplitCipher mCipher;
 
     StorageProvider(SplitRoomDatabase database, String apiKey, boolean encryptionEnabled, boolean shouldRecordTelemetry) {
         mDatabase = database;
-        mApiKey = apiKey;
-        mEncryptionEnabled = encryptionEnabled;
+        mCipher = SplitCipherFactory.create(apiKey, encryptionEnabled);
         mShouldRecordTelemetry = shouldRecordTelemetry;
     }
 
     SplitsStorage provideSplitsStorage() {
-        SplitsStorage splitsStorageForWorker = StorageFactory.getSplitsStorageForWorker(mDatabase, mApiKey, mEncryptionEnabled);
+        SplitsStorage splitsStorageForWorker = StorageFactory.getSplitsStorage(mDatabase, mCipher);
         splitsStorageForWorker.loadLocal(); // call loadLocal to populate storage with DB data
 
         return splitsStorageForWorker;
@@ -29,4 +30,11 @@ SplitsStorage provideSplitsStorage() {
     TelemetryStorage provideTelemetryStorage() {
         return StorageFactory.getTelemetryStorage(mShouldRecordTelemetry);
     }
+
+    RuleBasedSegmentStorageProducer provideRuleBasedSegmentStorage() {
+        RuleBasedSegmentStorageProducer ruleBasedSegmentStorageForWorker = StorageFactory.getRuleBasedSegmentStorageForWorker(mDatabase, mCipher);
+        ruleBasedSegmentStorageForWorker.loadLocal(); // call loadLocal to populate storage with DB data
+
+        return ruleBasedSegmentStorageForWorker;
+    }
 }

src/main/java/io/split/android/client/service/workmanager/splits/SyncHelperProvider.java

@@ -4,17 +4,21 @@
 import io.split.android.client.service.http.HttpFetcher;
 import io.split.android.client.service.splits.SplitChangeProcessor;
 import io.split.android.client.service.splits.SplitsSyncHelper;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorageProducer;
 import io.split.android.client.storage.splits.SplitsStorage;
 import io.split.android.client.telemetry.storage.TelemetryStorage;
 
 class SyncHelperProvider {
 
-    SplitsSyncHelper provideSplitsSyncHelper(HttpFetcher<TargetingRulesChange> splitsFetcher, SplitsStorage splitsStorage,
-                                             SplitChangeProcessor mSplitChangeProcessor,
+    SplitsSyncHelper provideSplitsSyncHelper(HttpFetcher<TargetingRulesChange> splitsFetcher,
+                                             SplitsStorage splitsStorage,
+                                             SplitChangeProcessor splitChangeProcessor,
+                                             RuleBasedSegmentStorageProducer ruleBasedSegmentStorage,
                                              TelemetryStorage telemetryStorage,
                                              String mFlagsSpec) {
         return new SplitsSyncHelper(splitsFetcher, splitsStorage,
-                mSplitChangeProcessor,
+                splitChangeProcessor,
+                ruleBasedSegmentStorage,
                 telemetryStorage,
                 mFlagsSpec);
     }

src/main/java/io/split/android/client/storage/common/SplitStorageContainer.java

@@ -18,9 +18,13 @@
 import io.split.android.client.storage.mysegments.MySegmentsStorage;
 import io.split.android.client.storage.mysegments.MySegmentsStorageContainer;
 import io.split.android.client.storage.rbs.PersistentRuleBasedSegmentStorage;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorage;
+import io.split.android.client.storage.rbs.RuleBasedSegmentStorageImpl;
 import io.split.android.client.storage.splits.PersistentSplitsStorage;
 import io.split.android.client.storage.splits.SplitsStorage;
 import io.split.android.client.telemetry.storage.TelemetryStorage;
+import io.split.android.engine.experiments.ParserCommons;
+import io.split.android.engine.experiments.RuleBasedSegmentParser;
 
 public class SplitStorageContainer {
 
@@ -39,7 +43,8 @@ public class SplitStorageContainer {
     private final PersistentImpressionsUniqueStorage mPersistentImpressionsUniqueStorage;
     private final PersistentImpressionsObserverCacheStorage mPersistentImpressionsObserverCacheStorage;
     private final GeneralInfoStorage mGeneralInfoStorage;
-    private final PersistentRuleBasedSegmentStorage mPersistentRuleBasedSegmentStorage;
+    private final ParserCommons mParserCommons;
+    private final RuleBasedSegmentStorage mRuleBasedSegmentStorage;
 
     public SplitStorageContainer(@NonNull SplitsStorage splitStorage,
                                  @NonNull MySegmentsStorageContainer mySegmentsStorageContainer,
@@ -73,7 +78,10 @@ public SplitStorageContainer(@NonNull SplitsStorage splitStorage,
         mPersistentImpressionsUniqueStorage = checkNotNull(persistentImpressionsUniqueStorage);
         mPersistentImpressionsObserverCacheStorage = checkNotNull(persistentImpressionsObserverCacheStorage);
         mGeneralInfoStorage = checkNotNull(generalInfoStorage);
-        mPersistentRuleBasedSegmentStorage = checkNotNull(persistentRuleBasedSegmentStorage);
+        mParserCommons = new ParserCommons(
+                mySegmentsStorageContainer,
+                myLargeSegmentsStorageContainer);
+        mRuleBasedSegmentStorage = new RuleBasedSegmentStorageImpl(persistentRuleBasedSegmentStorage, new RuleBasedSegmentParser(mParserCommons));
     }
 
     public SplitsStorage getSplitsStorage() {
@@ -148,7 +156,11 @@ public GeneralInfoStorage getGeneralInfoStorage() {
         return mGeneralInfoStorage;
     }
 
-    public PersistentRuleBasedSegmentStorage getPersistentRuleBasedSegmentStorage() {
-        return mPersistentRuleBasedSegmentStorage;
+    public ParserCommons getParserCommons() {
+        return mParserCommons;
+    }
+
+    public RuleBasedSegmentStorage getRuleBasedSegmentStorage() {
+        return mRuleBasedSegmentStorage;
     }
 }