Merge pull request #30 from launchdarkly/jko/redis-store

Support for optional Redis-backed feature store

Author: jkodumal

build.gradle

@@ -11,7 +11,7 @@ repositories {
 
 allprojects {
     group = 'com.launchdarkly'
-    version = "0.16.0"
+    version = "0.17.3-SNAPSHOT"
     sourceCompatibility = 1.6
     targetCompatibility = 1.6
 }
@@ -21,8 +21,10 @@ dependencies {
     compile "org.apache.httpcomponents:httpclient-cache:4.3.6"
     compile "commons-codec:commons-codec:1.5"
     compile "com.google.code.gson:gson:2.2.4"
+    compile "com.google.guava:guava:19.0"
     compile "org.slf4j:slf4j-api:1.7.7"
     compile "org.glassfish.jersey.media:jersey-media-sse:2.20"
+    compile "redis.clients:jedis:2.8.0"
     testCompile "org.easymock:easymock:3.3"
     testCompile 'junit:junit:[4.10,)'
     testRuntime "org.slf4j:slf4j-simple:1.7.7"

src/main/java/com/launchdarkly/client/LDConfig.java

@@ -33,6 +33,7 @@ public final class LDConfig {
   final HttpHost proxyHost;
   final boolean stream;
   final boolean debugStreaming;
+  final FeatureStore featureStore;
 
   protected LDConfig(Builder builder) {
     this.baseURI = builder.baseURI;
@@ -44,6 +45,7 @@ protected LDConfig(Builder builder) {
     this.streamURI = builder.streamURI;
     this.stream = builder.stream;
     this.debugStreaming = builder.debugStreaming;
+    this.featureStore = builder.featureStore;
   }
 
   /**
@@ -70,6 +72,7 @@ public static class Builder{
     private String proxyScheme;
     private boolean stream = true;
     private boolean debugStreaming = false;
+    private FeatureStore featureStore = new InMemoryFeatureStore();
 
     /**
      * Creates a builder with all configuration parameters set to the default
@@ -97,6 +100,11 @@ public Builder streamURI(URI streamURI) {
       return this;
     }
 
+    public Builder featureStore(FeatureStore store) {
+      this.featureStore = store;
+      return this;
+    }
+
     /**
      * Set whether we should debug streaming mode. If set, the client will fetch features via polling and compare the
      * retrieved feature with the value in the feature store. There is a performance cost to this, so it is not
@@ -266,7 +274,6 @@ public LDConfig build() {
 
   }
 
-
   private URIBuilder getBuilder() {
     return new URIBuilder()
         .setScheme(baseURI.getScheme())

src/main/java/com/launchdarkly/client/RedisFeatureStore.java

@@ -0,0 +1,175 @@
+package com.launchdarkly.client;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import org.apache.http.util.EntityUtils;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.Transaction;
+
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public class RedisFeatureStore implements FeatureStore {
+  private static final String DEFAULT_PREFIX = "launchdarkly";
+  private final Jedis jedis;
+  private LoadingCache<String, FeatureRep<?>> cache;
+  private String prefix;
+
+  public RedisFeatureStore(String host, int port, String prefix, long cacheTimeSecs) {
+    jedis = new Jedis(host, port);
+    setPrefix(prefix);
+    createCache(cacheTimeSecs);
+  }
+
+  public RedisFeatureStore(URI uri, String prefix, long cacheTimeSecs) {
+    jedis = new Jedis(uri);
+    setPrefix(prefix);
+    createCache(cacheTimeSecs);
+  }
+
+  public RedisFeatureStore() {
+    jedis = new Jedis("localhost");
+    this.prefix = DEFAULT_PREFIX;
+  }
+
+
+  private void setPrefix(String prefix) {
+    if (prefix == null || prefix.isEmpty()) {
+      this.prefix = DEFAULT_PREFIX;
+    } else {
+      this.prefix = prefix;
+    }
+  }
+
+  private void createCache(long cacheTimeSecs) {
+    if (cacheTimeSecs > 0) {
+      cache = CacheBuilder.newBuilder().expireAfterWrite(cacheTimeSecs, TimeUnit.SECONDS).build(new CacheLoader<String, FeatureRep<?>>() {
+
+        @Override
+        public FeatureRep<?> load(String key) throws Exception {
+          return getRedis(key);
+        }
+      });
+    }
+  }
+
+
+  @Override
+  public FeatureRep<?> get(String key) {
+    if (cache != null) {
+      return cache.getUnchecked(key);
+    } else {
+      return getRedis(key);
+    }
+  }
+
+  @Override
+  public Map<String, FeatureRep<?>> all() {
+    Map<String,String> featuresJson = jedis.hgetAll(featuresKey());
+    Map<String, FeatureRep<?>> result = new HashMap<String, FeatureRep<?>>();
+    Gson gson = new Gson();
+
+    Type type = new TypeToken<FeatureRep<?>>() {}.getType();
+
+    for (Map.Entry<String, String> entry : featuresJson.entrySet()) {
+      FeatureRep<?> rep =  gson.fromJson(entry.getValue(), type);
+      result.put(entry.getKey(), rep);
+    }
+
+    return result;
+  }
+
+  @Override
+  public void init(Map<String, FeatureRep<?>> features) {
+    Gson gson = new Gson();
+    Transaction t = jedis.multi();
+
+    t.del(featuresKey());
+
+    for (FeatureRep<?> f: features.values()) {
+      t.hset(featuresKey(), f.key, gson.toJson(f));
+    }
+
+    t.exec();
+  }
+
+  @Override
+  public void delete(String key, int version) {
+    try {
+      Gson gson = new Gson();
+      jedis.watch(featuresKey());
+
+      FeatureRep<?> feature = getRedis(key);
+
+      if (feature != null && feature.version >= version) {
+        return;
+      }
+
+      feature.deleted = true;
+      feature.version = version;
+
+      jedis.hset(featuresKey(), key, gson.toJson(feature));
+
+      if (cache != null) {
+        cache.invalidate(key);
+      }
+    }
+    finally {
+      jedis.unwatch();
+    }
+
+  }
+
+  @Override
+  public void upsert(String key, FeatureRep<?> feature) {
+    try {
+      Gson gson = new Gson();
+      jedis.watch(featuresKey());
+
+      FeatureRep<?> f = getRedis(key);
+
+      if (f != null && f.version >= feature.version) {
+        return;
+      }
+
+      jedis.hset(featuresKey(), key, gson.toJson(feature));
+
+      if (cache != null) {
+        cache.invalidate(key);
+      }
+    }
+    finally {
+      jedis.unwatch();
+    }
+  }
+
+  @Override
+  public boolean initialized() {
+    return jedis.exists(featuresKey());
+  }
+
+
+  private String featuresKey() {
+    return prefix + ":features";
+  }
+
+  private FeatureRep<?> getRedis(String key) {
+    Gson gson = new Gson();
+    String featureJson = jedis.hget(featuresKey(), key);
+
+    if (featureJson == null) {
+      return null;
+    }
+
+    Type type = new TypeToken<FeatureRep<?>>() {}.getType();
+    FeatureRep<?> f = gson.fromJson(featureJson, type);
+
+    return f.deleted ? null : f;
+  }
+}

src/main/java/com/launchdarkly/client/StreamProcessor.java

@@ -35,7 +35,7 @@ class StreamProcessor implements Closeable {
 
   StreamProcessor(String apiKey, LDConfig config, FeatureRequestor requestor) {
     this.client = ClientBuilder.newBuilder().register(SseFeature.class).build();
-    this.store = new InMemoryFeatureStore();
+    this.store = config.featureStore;
     this.config = config;
     this.apiKey = apiKey;
     this.requestor = requestor;

src/main/java/com/launchdarkly/client/Variation.java

@@ -15,7 +15,7 @@ class Variation<E> {
   int weight;
   TargetRule userTarget;
   List<TargetRule> targets;
-  private final Logger logger = LoggerFactory.getLogger(Variation.class);
+  private final static Logger logger = LoggerFactory.getLogger(Variation.class);
 
   public Variation() {
 
@@ -117,7 +117,7 @@ static class TargetRule {
     String operator;
     List<JsonPrimitive> values;
 
-    private final Logger logger = LoggerFactory.getLogger(TargetRule.class);
+    private final static Logger logger = LoggerFactory.getLogger(TargetRule.class);
 
     public TargetRule() {
 

src/test/java/com/launchdarkly/client/FeatureRepTest.java

@@ -102,7 +102,7 @@ public void testFlagForTargetedUserOn() {
   @Test
   public void testFlagForTargetGroupOn() {
     LDUser user = new LDUser.Builder("[email protected]")
-        .custom("groups", Arrays.asList("google", "microsoft"))
+        .customString("groups", Arrays.asList("google", "microsoft"))
         .build();
 
     Boolean b = simpleFlag.evaluate(user);