SqLite persistent storage implementation for RBS

src/main/java/io/split/android/client/storage/rbs/Clearer.java

@@ -0,0 +1,29 @@
+package io.split.android.client.storage.rbs;
+
+import static io.split.android.client.utils.Utils.checkNotNull;
+
+import io.split.android.client.storage.db.rbs.RuleBasedSegmentDao;
+import io.split.android.client.storage.general.GeneralInfoStorage;
+import io.split.android.client.utils.logger.Logger;
+
+class Clearer implements Runnable {
+
+    private final RuleBasedSegmentDao mDao;
+    private final GeneralInfoStorage mGeneralInfoStorage;
+
+    public Clearer(RuleBasedSegmentDao dao, GeneralInfoStorage generalInfoStorage) {
+        mDao = checkNotNull(dao);
+        mGeneralInfoStorage = checkNotNull(generalInfoStorage);
+    }
+
+    @Override
+    public void run() {
+        try {
+            mDao.deleteAll();
+            mGeneralInfoStorage.setRbsChangeNumber(-1);
+        } catch (Exception e) {
+            Logger.e("Error clearing RBS: " + e.getLocalizedMessage());
+            throw e;
+        }
+    }
+}

src/main/java/io/split/android/client/storage/rbs/PersistentRuleBasedSegmentStorage.java

@@ -11,4 +11,9 @@ public interface PersistentRuleBasedSegmentStorage {
     void update(Set<RuleBasedSegment> toAdd, Set<RuleBasedSegment> toRemove, long changeNumber);
 
     void clear();
+
+    interface Provider {
+
+        PersistentRuleBasedSegmentStorage get();
+    }
 }

src/main/java/io/split/android/client/storage/rbs/RuleBasedSegmentSnapshot.java

@@ -1,21 +1,25 @@
 package io.split.android.client.storage.rbs;
 
-import java.util.Set;
+import static io.split.android.client.utils.Utils.checkNotNull;
+
+import androidx.annotation.NonNull;
+
+import java.util.Map;
 
 import io.split.android.client.dtos.RuleBasedSegment;
 
 public class RuleBasedSegmentSnapshot {
 
-    private final Set<RuleBasedSegment> mSegments;
+    private final Map<String, RuleBasedSegment> mSegments;
 
     private final long mChangeNumber;
 
-    public RuleBasedSegmentSnapshot(Set<RuleBasedSegment> segments, long changeNumber) {
-        mSegments = segments;
+    public RuleBasedSegmentSnapshot(@NonNull Map<String, RuleBasedSegment> segments, long changeNumber) {
+        mSegments = checkNotNull(segments);
         mChangeNumber = changeNumber;
     }
 
-    public Set<RuleBasedSegment> getSegments() {
+    public Map<String, RuleBasedSegment> getSegments() {
         return mSegments;
     }
 

src/main/java/io/split/android/client/storage/rbs/RuleBasedSegmentStorageImpl.java

@@ -6,6 +6,7 @@
 import androidx.annotation.Nullable;
 import androidx.annotation.WorkerThread;
 
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -77,13 +78,11 @@ public boolean contains(@NonNull Set<String> segmentNames) {
 
     @WorkerThread
     @Override
-    public void loadLocal() {
+    public synchronized void loadLocal() {
         RuleBasedSegmentSnapshot snapshot = mPersistentStorage.getSnapshot();
-        Set<RuleBasedSegment> segments = snapshot.getSegments();
+        Map<String, RuleBasedSegment> segments = snapshot.getSegments();
         mChangeNumber = snapshot.getChangeNumber();
-        for (RuleBasedSegment segment : segments) {
-            mInMemorySegments.put(segment.getName(), segment);
-        }
+        mInMemorySegments.putAll(segments);
     }
 
     @WorkerThread

src/main/java/io/split/android/client/storage/rbs/SnapshotLoader.java

@@ -0,0 +1,68 @@
+package io.split.android.client.storage.rbs;
+
+import static io.split.android.client.utils.Utils.checkNotNull;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+import io.split.android.client.storage.cipher.SplitCipher;
+import io.split.android.client.storage.db.rbs.RuleBasedSegmentDao;
+import io.split.android.client.storage.db.rbs.RuleBasedSegmentEntity;
+import io.split.android.client.storage.general.GeneralInfoStorage;
+import io.split.android.client.utils.Json;
+import io.split.android.client.utils.logger.Logger;
+
+final class SnapshotLoader implements Callable<RuleBasedSegmentSnapshot> {
+
+    private final RuleBasedSegmentDao mDao;
+    private final SplitCipher mCipher;
+    private final GeneralInfoStorage mGeneralInfoStorage;
+
+    SnapshotLoader(RuleBasedSegmentDao dao, SplitCipher cipher, GeneralInfoStorage generalInfoStorage) {
+        mDao = checkNotNull(dao);
+        mCipher = checkNotNull(cipher);
+        mGeneralInfoStorage = checkNotNull(generalInfoStorage);
+    }
+
+    @Override
+    public RuleBasedSegmentSnapshot call() {
+        try {
+            long changeNumber = mGeneralInfoStorage.getFlagsChangeNumber();
+            List<RuleBasedSegmentEntity> entities = mDao.getAll();
+            Map<String, RuleBasedSegment> segments = convertToDTOs(entities);
+
+            return new RuleBasedSegmentSnapshot(segments, changeNumber);
+        } catch (Exception e) {
+            Logger.e("Error loading RBS from persistent storage", e.getLocalizedMessage());
+            throw e;
+        }
+    }
+
+    @NonNull
+    private Map<String, RuleBasedSegment> convertToDTOs(@Nullable List<RuleBasedSegmentEntity> entities) {
+        Map<String, RuleBasedSegment> segments = new HashMap<>();
+        if (entities != null) {
+            for (RuleBasedSegmentEntity entity : entities) {
+                String name = mCipher.decrypt(entity.getName());
+                String body = mCipher.decrypt(entity.getBody());
+                if (name == null || body == null) {
+                    continue;
+                }
+
+                try {
+                    RuleBasedSegment ruleBasedSegment = Json.fromJson(body, RuleBasedSegment.class);
+                    segments.put(name, ruleBasedSegment);
+                } catch (Exception e) {
+                    Logger.e("Error parsing RBS with name " + name + ": " + e.getLocalizedMessage());
+                }
+            }
+        }
+        return segments;
+    }
+}

src/main/java/io/split/android/client/storage/rbs/SqLitePersistentRuleBasedSegmentStorage.java

@@ -0,0 +1,43 @@
+package io.split.android.client.storage.rbs;
+
+import static io.split.android.client.utils.Utils.checkNotNull;
+
+import java.util.Set;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+import io.split.android.client.storage.cipher.SplitCipher;
+import io.split.android.client.storage.db.SplitRoomDatabase;
+import io.split.android.client.storage.db.rbs.RuleBasedSegmentDao;
+import io.split.android.client.storage.general.GeneralInfoStorage;
+
+class SqLitePersistentRuleBasedSegmentStorage implements PersistentRuleBasedSegmentStorage {
+
+    private final RuleBasedSegmentDao mDao;
+    private final SplitRoomDatabase mDatabase;
+    private final GeneralInfoStorage mGeneralInfoStorage;
+    private final SplitCipher mCipher;
+
+    public SqLitePersistentRuleBasedSegmentStorage(SplitCipher cipher,
+                                                   SplitRoomDatabase database,
+                                                   GeneralInfoStorage generalInfoStorage) {
+        mCipher = checkNotNull(cipher);
+        mDatabase = checkNotNull(database);
+        mDao = database.ruleBasedSegmentDao();
+        mGeneralInfoStorage = checkNotNull(generalInfoStorage);
+    }
+
+    @Override
+    public RuleBasedSegmentSnapshot getSnapshot() {
+        return mDatabase.runInTransaction(new SnapshotLoader(mDao, mCipher, mGeneralInfoStorage));
+    }
+
+    @Override
+    public void update(Set<RuleBasedSegment> toAdd, Set<RuleBasedSegment> toRemove, long changeNumber) {
+        mDatabase.runInTransaction(new Updater(mCipher, mDao, mGeneralInfoStorage, toAdd, toRemove, changeNumber));
+    }
+
+    @Override
+    public void clear() {
+        mDatabase.runInTransaction(new Clearer(mDao, mGeneralInfoStorage));
+    }
+}

src/main/java/io/split/android/client/storage/rbs/SqLitePersistentRuleBasedSegmentStorageProvider.java

@@ -0,0 +1,19 @@
+package io.split.android.client.storage.rbs;
+
+import io.split.android.client.storage.cipher.SplitCipher;
+import io.split.android.client.storage.db.SplitRoomDatabase;
+import io.split.android.client.storage.general.GeneralInfoStorage;
+
+public class SqLitePersistentRuleBasedSegmentStorageProvider implements PersistentRuleBasedSegmentStorage.Provider {
+
+    private final SqLitePersistentRuleBasedSegmentStorage mPersistentStorage;
+
+    public SqLitePersistentRuleBasedSegmentStorageProvider(SplitCipher cipher, SplitRoomDatabase database, GeneralInfoStorage generalInfoStorage) {
+        mPersistentStorage = new SqLitePersistentRuleBasedSegmentStorage(cipher, database, generalInfoStorage);
+    }
+
+    @Override
+    public PersistentRuleBasedSegmentStorage get() {
+        return mPersistentStorage;
+    }
+}

src/main/java/io/split/android/client/storage/rbs/Updater.java

@@ -0,0 +1,84 @@
+package io.split.android.client.storage.rbs;
+
+import static io.split.android.client.utils.Utils.checkNotNull;
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+import io.split.android.client.storage.cipher.SplitCipher;
+import io.split.android.client.storage.db.rbs.RuleBasedSegmentDao;
+import io.split.android.client.storage.db.rbs.RuleBasedSegmentEntity;
+import io.split.android.client.storage.general.GeneralInfoStorage;
+import io.split.android.client.utils.Json;
+import io.split.android.client.utils.logger.Logger;
+
+final class Updater implements Runnable {
+
+    @NonNull
+    private final SplitCipher mCipher;
+    @NonNull
+    private final GeneralInfoStorage mGeneralInfoStorage;
+    @NonNull
+    private final RuleBasedSegmentDao mDao;
+    @NonNull
+    private final Set<RuleBasedSegment> mToAdd;
+    @NonNull
+    private final Set<RuleBasedSegment> mToRemove;
+    private final long mChangeNumber;
+
+    Updater(@NonNull SplitCipher cipher,
+            @NonNull RuleBasedSegmentDao dao,
+            @NonNull GeneralInfoStorage generalInfoStorage,
+            @NonNull Set<RuleBasedSegment> toAdd,
+            @NonNull Set<RuleBasedSegment> toRemove,
+            long changeNumber) {
+        mCipher = checkNotNull(cipher);
+        mDao = checkNotNull(dao);
+        mGeneralInfoStorage = checkNotNull(generalInfoStorage);
+        mToAdd = checkNotNull(toAdd);
+        mToRemove = checkNotNull(toRemove);
+        mChangeNumber = changeNumber;
+    }
+
+    @Override
+    public void run() {
+        try {
+            List<String> toDelete = new ArrayList<>();
+            for (RuleBasedSegment segment : mToRemove) {
+                String encryptedName = mCipher.encrypt(segment.getName());
+                if (encryptedName != null) {
+                    toDelete.add(encryptedName);
+                }
+            }
+
+            List<RuleBasedSegmentEntity> toAdd = new ArrayList<>();
+            for (RuleBasedSegment segment : mToAdd) {
+                if (segment == null) {
+                    continue;
+                }
+
+                try {
+                    String name = mCipher.encrypt(segment.getName());
+                    String body = mCipher.encrypt(Json.toJson(segment));
+                    if (name == null || body == null) {
+                        continue;
+                    }
+                    toAdd.add(new RuleBasedSegmentEntity(name, body, System.currentTimeMillis()));
+                } catch (Exception e) {
+                    Logger.e("Error parsing RBS with name " + segment.getName() + ": " + e.getLocalizedMessage());
+                }
+            }
+
+            mDao.delete(toDelete);
+            mDao.insert(toAdd);
+            mGeneralInfoStorage.setRbsChangeNumber(mChangeNumber);
+        } catch (Exception e) {
+            Logger.e("Error updating RBS: " + e.getLocalizedMessage());
+            throw e;
+        }
+    }
+}

src/sharedTest/java/helper/TestingHelper.java

@@ -1,5 +1,8 @@
 package helper;
 
+import static java.lang.Thread.sleep;
+
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
@@ -12,8 +15,6 @@
 import io.split.android.client.events.SplitEventTask;
 import io.split.android.client.utils.logger.Logger;
 
-import static java.lang.Thread.sleep;
-
 public class TestingHelper {
 
     public static final String COUNTERS_REFRESH_RATE_SECS_NAME = "COUNTERS_REFRESH_RATE_SECS";
@@ -120,4 +121,14 @@ public static KeyImpression newImpression(String feature, String key) {
         impression.time = 100;
         return impression;
     }
+
+    public static Object getFieldValue(Object object, String fieldName) {
+        try {
+            Field field = object.getClass().getDeclaredField(fieldName);
+            field.setAccessible(true);
+            return field.get(object);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new RuntimeException("Error accessing field: " + fieldName, e);
+        }
+    }
 }

src/test/java/io/split/android/client/storage/rbs/RuleBasedSegmentStorageImplTest.java

@@ -16,6 +16,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 
 import io.split.android.client.dtos.Excluded;
@@ -159,15 +160,15 @@ public void updateReturnsTrueWhenThereWereAddedSegments() {
 
     @Test
     public void loadLocalGetsSnapshotFromPersistentStorage() {
-        when(mPersistentStorage.getSnapshot()).thenReturn(new RuleBasedSegmentSnapshot(Set.of(), 1));
+        when(mPersistentStorage.getSnapshot()).thenReturn(new RuleBasedSegmentSnapshot(Map.of(), 1));
         storage.loadLocal();
 
         verify(mPersistentStorage).getSnapshot();
     }
 
     @Test
     public void loadLocalPopulatesValues() {
-        RuleBasedSegmentSnapshot snapshot = new RuleBasedSegmentSnapshot(Set.of(createRuleBasedSegment("segment1")),
+        RuleBasedSegmentSnapshot snapshot = new RuleBasedSegmentSnapshot(Map.of("segment1", createRuleBasedSegment("segment1")),
                 1);
         when(mPersistentStorage.getSnapshot()).thenReturn(snapshot);
 
@@ -192,7 +193,7 @@ public void clearCallsClearOnPersistentStorage() {
         verify(mPersistentStorage).clear();
     }
 
-    private static RuleBasedSegment createRuleBasedSegment(String name) {
+    static RuleBasedSegment createRuleBasedSegment(String name) {
         return new RuleBasedSegment(name,
                 "user",
                 1,