RBS in memory storage

.github/workflows/instrumented.yml

@@ -5,7 +5,6 @@ on:
     branches:
       - 'development'
       - 'master'
-      - '*_baseline'
 
 jobs:
   test:

src/main/java/io/split/android/client/localhost/LocalhostMySegmentsStorageContainer.java

@@ -18,6 +18,11 @@ public long getUniqueAmount() {
         return mEmptyMySegmentsStorage.getAll().size();
     }
 
+    @Override
+    public void loadLocal() {
+        // no-op
+    }
+
     @Override
     public void clear() {
         // No-op

src/main/java/io/split/android/client/storage/RolloutDefinitionsCache.java

@@ -2,5 +2,7 @@
 
 public interface RolloutDefinitionsCache {
 
+    void loadLocal();
+
     void clear();
 }

src/main/java/io/split/android/client/storage/mysegments/MySegmentsStorage.java

@@ -6,7 +6,6 @@
 import io.split.android.client.storage.RolloutDefinitionsCache;
 
 public interface MySegmentsStorage extends RolloutDefinitionsCache {
-    void loadLocal();
 
     Set<String> getAll();
 

src/main/java/io/split/android/client/storage/mysegments/MySegmentsStorageContainerImpl.java

@@ -42,6 +42,11 @@ public long getUniqueAmount() {
         return segments.size();
     }
 
+    @Override
+    public void loadLocal() {
+        // no-op
+    }
+
     @Override
     public void clear() {
         synchronized (lock) {

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

@@ -0,0 +1,14 @@
+package io.split.android.client.storage.rbs;
+
+import java.util.Set;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+
+public interface PersistentRuleBasedSegmentStorage {
+
+    RuleBasedSegmentSnapshot getSnapshot();
+
+    boolean update(Set<RuleBasedSegment> toAdd, Set<RuleBasedSegment> toRemove, long changeNumber);
+
+    void clear();
+}

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

@@ -0,0 +1,25 @@
+package io.split.android.client.storage.rbs;
+
+import java.util.Set;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+
+public class RuleBasedSegmentSnapshot {
+
+    private final Set<RuleBasedSegment> mSegments;
+
+    private final long mChangeNumber;
+
+    public RuleBasedSegmentSnapshot(Set<RuleBasedSegment> segments, long changeNumber) {
+        mSegments = segments;
+        mChangeNumber = changeNumber;
+    }
+
+    public Set<RuleBasedSegment> getSegments() {
+        return mSegments;
+    }
+
+    public long getChangeNumber() {
+        return mChangeNumber;
+    }
+}

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

@@ -0,0 +1,21 @@
+package io.split.android.client.storage.rbs;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.util.Set;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+import io.split.android.client.storage.RolloutDefinitionsCache;
+
+public interface RuleBasedSegmentStorage extends RolloutDefinitionsCache {
+
+    @Nullable
+    RuleBasedSegment get(String segmentName);
+
+    boolean update(@NonNull Set<RuleBasedSegment> toAdd, @NonNull Set<RuleBasedSegment> toRemove, long changeNumber);
+
+    long getChangeNumber();
+
+    boolean contains(@NonNull Set<String> segmentNames);
+}

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

@@ -0,0 +1,96 @@
+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 androidx.annotation.WorkerThread;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import io.split.android.client.dtos.RuleBasedSegment;
+
+public class RuleBasedSegmentStorageImpl implements RuleBasedSegmentStorage {
+
+    private final ConcurrentHashMap<String, RuleBasedSegment> mInMemorySegments;
+    private final PersistentRuleBasedSegmentStorage mPersistentStorage;
+    private volatile long mChangeNumber;
+
+    public RuleBasedSegmentStorageImpl(@NonNull PersistentRuleBasedSegmentStorage persistentStorage) {
+        mInMemorySegments = new ConcurrentHashMap<>();
+        mPersistentStorage = checkNotNull(persistentStorage);
+        mChangeNumber = -1;
+    }
+
+    @Nullable
+    @Override
+    public RuleBasedSegment get(String segmentName) {
+        return mInMemorySegments.get(segmentName);
+    }
+
+    @Override
+    public synchronized boolean update(@NonNull Set<RuleBasedSegment> toAdd, @NonNull Set<RuleBasedSegment> toRemove, long changeNumber) {
+        boolean appliedUpdates = false;
+
+        if (toAdd != null) {
+            if (!toAdd.isEmpty()) {
+                for (RuleBasedSegment segment : toAdd) {
+                    mInMemorySegments.put(segment.getName(), segment);
+                }
+
+                appliedUpdates = true;
+            }
+        }
+
+        if (toRemove != null) {
+            if (!toRemove.isEmpty()) {
+                for (RuleBasedSegment segment : toRemove) {
+                    mInMemorySegments.remove(segment.getName());
+                }
+            }
+        }
+
+        mChangeNumber = changeNumber;
+
+        return appliedUpdates;
+    }
+
+    @Override
+    public long getChangeNumber() {
+        return mChangeNumber;
+    }
+
+    @Override
+    public boolean contains(@NonNull Set<String> segmentNames) {
+        if (segmentNames == null) {
+            return false;
+        }
+
+        for (String name : segmentNames) {
+            if (!mInMemorySegments.containsKey(name)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @WorkerThread
+    @Override
+    public void loadLocal() {
+        RuleBasedSegmentSnapshot snapshot = mPersistentStorage.getSnapshot();
+        Set<RuleBasedSegment> segments = snapshot.getSegments();
+        mChangeNumber = snapshot.getChangeNumber();
+        for (RuleBasedSegment segment : segments) {
+            mInMemorySegments.put(segment.getName(), segment);
+        }
+    }
+
+    @WorkerThread
+    @Override
+    public void clear() {
+        mInMemorySegments.clear();
+        mChangeNumber = -1;
+        mPersistentStorage.clear();
+    }
+}

src/main/java/io/split/android/client/storage/splits/SplitsStorage.java

@@ -12,7 +12,6 @@
 import io.split.android.client.storage.RolloutDefinitionsCache;
 
 public interface SplitsStorage extends RolloutDefinitionsCache {
-    void loadLocal();
 
     Split get(@NonNull String name);