[4.1.4] Development to master

client/CHANGES.txt

@@ -1,5 +1,11 @@
 CHANGES
 
+4.1.4 (Mar 19, 2021)
+- Updated: Internal cache structure refactor.
+- Updated: Streaming revamp with several bugfixes and improved log messages.
+- Added: Cache-Control header for on-demand requests to sdk-server.
+- Updated: Localhost Client revamp & bugfix for missing splits.
+
 4.1.3 (Dec 2, 2020)
 - Fix Issue when closing SSE Connection
 - Updated log-level for some messages

client/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>io.split.client</groupId>
         <artifactId>java-client-parent</artifactId>
-        <version>4.1.3</version>
+        <version>4.1.4</version>
     </parent>
     <artifactId>java-client</artifactId>
     <packaging>jar</packaging>

client/src/main/java/io/split/cache/InMemoryCacheImp.java

@@ -0,0 +1,126 @@
+package io.split.cache;
+
+import com.google.common.collect.ConcurrentHashMultiset;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.Sets;
+import io.split.engine.experiments.ParsedSplit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class InMemoryCacheImp implements SplitCache {
+
+    private static final Logger _log = LoggerFactory.getLogger(InMemoryCacheImp.class);
+
+    private final ConcurrentMap<String, ParsedSplit> _concurrentMap;
+    private final Multiset<String> _concurrentTrafficTypeNameSet;
+
+    private AtomicLong _changeNumber;
+
+    public InMemoryCacheImp() {
+        this(-1);
+    }
+
+    public InMemoryCacheImp(long startingChangeNumber) {
+        _concurrentMap = Maps.newConcurrentMap();
+        _changeNumber = new AtomicLong(startingChangeNumber);
+        _concurrentTrafficTypeNameSet = ConcurrentHashMultiset.create();
+    }
+
+    @Override
+    public void put(ParsedSplit split) {
+        _concurrentMap.put(split.feature(), split);
+
+        if (split.trafficTypeName() != null) {
+            _concurrentTrafficTypeNameSet.add(split.trafficTypeName());
+        }
+    }
+
+    @Override
+    public boolean remove(String name) {
+        ParsedSplit removed = _concurrentMap.remove(name);
+
+        if (removed != null && removed.trafficTypeName() != null) {
+            _concurrentTrafficTypeNameSet.remove(removed.trafficTypeName());
+        }
+
+        return removed != null;
+    }
+
+    @Override
+    public ParsedSplit get(String name) {
+        return _concurrentMap.get(name);
+    }
+
+    @Override
+    public Collection<ParsedSplit> getAll() {
+        return _concurrentMap.values();
+    }
+
+    @Override
+    public Collection<ParsedSplit> getMany(List<String> names) {
+        List<ParsedSplit> splits = new ArrayList<>();
+
+        for (String name : names) {
+            ParsedSplit split = _concurrentMap.get(name);
+
+            if (split != null) {
+                splits.add(split);
+            }
+        }
+
+        return splits;
+    }
+
+    @Override
+    public long getChangeNumber() {
+        return _changeNumber.get();
+    }
+
+    @Override
+    public void setChangeNumber(long changeNumber) {
+        if (changeNumber < _changeNumber.get()) {
+            _log.error("ChangeNumber for splits cache is less than previous");
+        }
+
+        _changeNumber.set(changeNumber);
+    }
+
+    @Override
+    public boolean trafficTypeExists(String trafficTypeName) {
+        // If the multiset has [{"user",2}.{"account",0}], elementSet only returns
+        // ["user"] (it ignores "account")
+        return Sets.newHashSet(_concurrentTrafficTypeNameSet.elementSet()).contains(trafficTypeName);
+    }
+
+    @Override
+    public void kill(String splitName, String defaultTreatment, long changeNumber) {
+        ParsedSplit parsedSplit = _concurrentMap.get(splitName);
+
+        ParsedSplit updatedSplit = new ParsedSplit(parsedSplit.feature(),
+                parsedSplit.seed(),
+                true,
+                defaultTreatment,
+                parsedSplit.parsedConditions(),
+                parsedSplit.trafficTypeName(),
+                changeNumber,
+                parsedSplit.trafficAllocation(),
+                parsedSplit.trafficAllocationSeed(),
+                parsedSplit.algo(),
+                parsedSplit.configurations());
+
+        _concurrentMap.put(splitName, updatedSplit);
+    }
+
+    @Override
+    public void clear() {
+        _concurrentMap.clear();
+        _concurrentTrafficTypeNameSet.clear();
+    }
+}

client/src/main/java/io/split/cache/SegmentCache.java

@@ -0,0 +1,45 @@
+package io.split.cache;
+
+import java.util.List;
+
+/**
+ * Memory for segments
+ * @author lucasecheverz
+ */
+public interface SegmentCache {
+
+    /**
+     * update segment
+     * @param segmentName
+     * @param toAdd
+     * @param toRemove
+     */
+    void updateSegment(String segmentName, List<String> toAdd, List<String> toRemove) ;
+
+    /**
+     * evaluates if a key belongs to a segment
+     * @param segmentName
+     * @param key
+     * @return
+     */
+    boolean isInSegment(String segmentName, String key);
+
+    /**
+     * update the changeNumber of a segment
+     * @param segmentName
+     * @param changeNumber
+     */
+    void setChangeNumber(String segmentName, long changeNumber);
+
+    /**
+     * returns the changeNumber of a segment
+     * @param segmentName
+     * @return
+     */
+    long getChangeNumber(String segmentName);
+
+    /**
+     * clear all segments
+     */
+    void clear();
+}

client/src/main/java/io/split/cache/SegmentCacheInMemoryImpl.java

@@ -0,0 +1,62 @@
+package io.split.cache;
+
+import com.google.common.collect.Maps;
+import io.split.engine.segments.SegmentImp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * InMemoryCache Implementation
+ * @author lucasecheverz
+ */
+public class SegmentCacheInMemoryImpl implements SegmentCache {
+    private static final Logger _log = LoggerFactory.getLogger(SegmentCacheInMemoryImpl.class);
+    private static final long DEFAULT_CHANGE_NUMBER = -1l;
+    private final ConcurrentMap<String, SegmentImp> _segments = Maps.newConcurrentMap();
+
+    @Override
+    public void updateSegment(String segmentName, List<String> toAdd, List<String> toRemove) {
+        if(_segments.get(segmentName) == null){
+            _segments.put(segmentName, new SegmentImp(DEFAULT_CHANGE_NUMBER, segmentName,toAdd));
+        }
+
+        _segments.get(segmentName).update(toAdd,toRemove);
+    }
+
+    @Override
+    public boolean isInSegment(String segmentName, String key) {
+        SegmentImp segmentImp = _segments.get(segmentName);
+        if(segmentImp == null){
+            _log.error("Segment " + segmentName + "Not found.");
+            return false;
+        }
+        return segmentImp.contains(key);
+    }
+
+    @Override
+    public void setChangeNumber(String segmentName, long changeNumber) {
+        if(_segments.get(segmentName) == null){
+            _log.error("Segment " + segmentName + "Not found.");
+            return ;
+        }
+        _segments.get(segmentName).setChangeNumber(changeNumber);
+    }
+
+    @Override
+    public long getChangeNumber(String segmentName) {
+        SegmentImp segmentImp = _segments.get(segmentName);
+        if(segmentImp == null){
+            _log.error("Segment " + segmentName + "Not found.");
+            return DEFAULT_CHANGE_NUMBER;
+        }
+        return segmentImp.getChangeNumber();
+    }
+
+    @Override
+    public void clear() {
+        _segments.clear();
+    }
+}

client/src/main/java/io/split/cache/SplitCache.java

@@ -0,0 +1,19 @@
+package io.split.cache;
+
+import io.split.engine.experiments.ParsedSplit;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface SplitCache {
+    void put(ParsedSplit split);
+    boolean remove(String name);
+    ParsedSplit get(String name);
+    Collection<ParsedSplit> getAll();
+    Collection<ParsedSplit> getMany(List<String> names);
+    long getChangeNumber();
+    void setChangeNumber(long changeNumber);
+    boolean trafficTypeExists(String trafficTypeName);
+    void kill(String splitName, String defaultTreatment, long changeNumber);
+    void clear();
+}

client/src/main/java/io/split/client/ApiKeyCounter.java

@@ -0,0 +1,66 @@
+package io.split.client;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ConcurrentHashMultiset;
+import com.google.common.collect.Multiset;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ApiKeyCounter {
+
+    private static final Logger _log = LoggerFactory.getLogger(ApiKeyCounter.class);
+    private static final Multiset<String> USED_API_KEYS = ConcurrentHashMultiset.create();
+
+    private ApiKeyCounter() {}
+
+    public static ApiKeyCounter getApiKeyCounterInstance() {
+        return ApyKeyCounterHolder.INSTANCE;
+    }
+
+    //Inner class to provide instance of class
+    private static class ApyKeyCounterHolder
+    {
+        private static final ApiKeyCounter INSTANCE = new ApiKeyCounter();
+    }
+
+    public void add(String apiKey) {
+        String message;
+        if (USED_API_KEYS.contains(apiKey)) {
+            message = String.format("factory instantiation: You already have %s with this API Key. " +
+                            "We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing " +
+                            "it throughout your application.",
+                    USED_API_KEYS.count(apiKey) == 1 ? "1 factory" : String.format("%s factories", USED_API_KEYS.count(apiKey)));
+            _log.warn(message);
+        } else if (!USED_API_KEYS.isEmpty()) {
+             message = "factory instantiation: You already have an instance of the Split factory. " +
+                    "Make sure you definitely want this additional instance. We recommend keeping only one instance of " +
+                    "the factory at all times (Singleton pattern) and reusing it throughout your application.“";
+            _log.warn(message);
+        }
+        USED_API_KEYS.add(apiKey);
+    }
+
+    public void remove(String apiKey) {
+        USED_API_KEYS.remove(apiKey);
+    }
+
+    /**
+     * Just for test
+     * @param apiKey
+     * @return
+     */
+    @VisibleForTesting
+    boolean isApiKeyPresent(String apiKey) {
+        return USED_API_KEYS.contains(apiKey);
+    }
+
+    /**
+     * Just for test
+     * @param apiKey
+     * @return
+     */
+    @VisibleForTesting
+    int getCount(String apiKey) {
+        return USED_API_KEYS.count(apiKey);
+    }
+}