wip: java custom strategies evaluator, remove need for jackson

Author: chriswk

java-engine/build.gradle.kts

@@ -1,4 +1,5 @@
 plugins {
+    java
     `java-library`
     `maven-publish`
     signing
@@ -30,16 +31,17 @@ dependencies {
     testImplementation("org.junit.platform:junit-platform-launcher")
     testImplementation("org.junit.jupiter:junit-jupiter-engine")
     testImplementation("org.junit.jupiter:junit-jupiter-params")
+    testImplementation(libs.assert4j.core)
     testImplementation(libs.mockito.core)
     testImplementation(libs.slf4j.simple)
     implementation(libs.slf4j.api)
     implementation(libs.jna)
-    implementation(libs.jackson.core)
-    implementation(libs.jackson.databind)
-    implementation(libs.jackson.jsr310)
     implementation(libs.flatbuffers)
 }
 
+tasks.withType<Javadoc> {
+    exclude("io/getunleash/messaging/**")
+}
 tasks.jar {
     manifest {
         attributes(

java-engine/gradle/libs.versions.toml

@@ -1,4 +1,5 @@
 [versions]
+assertj = "3.27.6"
 flatbuffers = "25.2.10"
 jackson = "2.20.0"
 jmh = "1.37"
@@ -19,3 +20,4 @@ junit-bom = { group = "org.junit", name = "junit-bom", version.ref = "junit" }
 mockito-core = { group = "org.mockito", name = "mockito-core", version.ref = "mockito" }
 slf4j-api = { group = "org.slf4j", name = "slf4j-api", version.ref = "slf4j" }
 slf4j-simple = { group = "org.slf4j", name = "slf4j-simple", version.ref = "slf4j" }
+assert4j-core = { group = "org.assertj", name = "assertj-core", version.ref = "assertj" }

java-engine/src/main/java/io/getunleash/engine/CustomStrategiesEvaluator.java

@@ -6,10 +6,16 @@
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+
+import io.getunleash.messaging.StrategyDefinition;
+import io.getunleash.messaging.StrategyFeature;
+import io.getunleash.messaging.StrategyParameter;
+import io.getunleash.messaging.TakeStateResponse;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 class CustomStrategiesEvaluator {
+
   private static final Logger log = LoggerFactory.getLogger(CustomStrategiesEvaluator.class);
   static final Map<String, Boolean> EMPTY_STRATEGY_RESULTS = new HashMap<>();
   private final Map<String, IStrategy> registeredStrategies;
@@ -34,68 +40,75 @@ public CustomStrategiesEvaluator(
     this.fallbackStrategy = fallbackStrategy;
   }
 
-  public void loadStrategiesFor(String toggles) {
+  public void loadStrategiesFor(TakeStateResponse response) {
     if (this.registeredStrategies.isEmpty() && this.fallbackStrategy == null) {
       return;
     }
 
-    if (toggles == null || toggles.isEmpty()) {
+    if (response.featuresVector() == null || response.featuresLength() == 0) {
       return;
     }
-
-    try {
-      VersionedFeatures wrapper =
-          mapper.readValue(toggles, new TypeReference<VersionedFeatures>() {});
-      if (wrapper.features != null) {
-        featureStrategies =
-            wrapper.features.stream()
-                .collect(toMap(feature -> feature.name, this::getFeatureStrategies));
+    Map<String, List<MappedStrategy>> featureStrategies = new HashMap<>();
+    for (int i = 0; i < response.featuresLength(); i++) {
+      StrategyFeature feature = response.features(i);
+      String featureName = feature.featureName();
+      if (feature.strategiesLength() == 0) {
+        List<MappedStrategy> mappedStrategies = new ArrayList<>();
+        for (int j = 0; j < feature.strategiesLength(); j++) {
+          var strategy = feature.strategies(j);
+          if (builtinStrategies.contains(strategy.name())) {
+            continue;
+          }
+          featureStrategies.put(featureName, getFeatureStrategies(feature));
+        }
       }
-    } catch (JsonProcessingException e) {
-      log.warn(
-          "Error processing features. This means custom strategies will return false every time they're used",
-          e);
     }
+    this.featureStrategies = featureStrategies;
   }
 
-  List<MappedStrategy> getFeatureStrategies(FeatureDefinition feature) {
+  List<MappedStrategy> getFeatureStrategies(StrategyFeature feature) {
     List<MappedStrategy> mappedStrategies = new ArrayList<>();
     int index = 1;
-    for (StrategyDefinition strategyDefinition : feature.strategies) {
-      if (builtinStrategies.contains(strategyDefinition.name)) {
-        continue;
+    if (feature.strategiesLength() > 0) {
+      for (int i = 0; i < feature.strategiesLength(); i++) {
+        io.getunleash.messaging.StrategyDefinition strategy = feature.strategies(i);
+        if (builtinStrategies.contains(strategy.name())) {
+          continue;
+        }
+        IStrategy impl =
+            Optional.ofNullable(registeredStrategies.get(strategy.name()))
+                .orElseGet(() -> alwaysFalseStrategy(strategy.name()));
+        StrategyDefinition def =
+            new StrategyDefinition(strategy.name(), getStrategyParameters(strategy));
+        mappedStrategies.add(new MappedStrategy("customStrategy" + (index++), impl, def));
       }
-      IStrategy impl =
-          Optional.ofNullable(registeredStrategies.get(strategyDefinition.name))
-              .orElseGet(() -> alwaysFalseStrategy(strategyDefinition.name));
-      mappedStrategies.add(
-          new MappedStrategy("customStrategy" + (index++), impl, strategyDefinition));
-    }
-    if (fallbackStrategy != null) {
-      mappedStrategies.add(
-          new MappedStrategy(
-              "customStrategy" + index,
-              fallbackStrategy,
-              new StrategyDefinition("fallback", Collections.emptyMap())));
     }
     return mappedStrategies;
   }
 
+  Map<String, String> getStrategyParameters(io.getunleash.messaging.StrategyDefinition strategy) {
+    Map<String, String> parameters = new HashMap<>();
+    if (strategy.parametersLength() > 0) {
+      for (int i = 0; i < strategy.parametersLength(); i++) {
+        StrategyParameter parameter = strategy.parameters(i);
+        parameters.put(parameter.key(), parameter.value());
+      }
+    }
+    return parameters;
+  }
+
   public Map<String, Boolean> eval(String name, Context context) {
 
     List<MappedStrategy> mappedStrategies = featureStrategies.get(name);
     if (mappedStrategies == null || mappedStrategies.isEmpty()) {
       return Collections.emptyMap();
     }
 
-    Map<String, Boolean> results =
-        mappedStrategies.stream()
-            .collect(
-                Collectors.toMap(
-                    mappedStrategy -> mappedStrategy.resultName,
-                    mappedStrategy -> tryIsEnabled(context, mappedStrategy).orElse(false)));
-
-    return results;
+      return mappedStrategies.stream()
+          .collect(
+              Collectors.toMap(
+                  mappedStrategy -> mappedStrategy.resultName,
+                  mappedStrategy -> tryIsEnabled(context, mappedStrategy).orElse(false)));
   }
 
   private static Optional<Boolean> tryIsEnabled(Context context, MappedStrategy mappedStrategy) {
@@ -109,36 +122,11 @@ private static Optional<Boolean> tryIsEnabled(Context context, MappedStrategy ma
     }
   }
 
-  private static class VersionedFeatures {
-    private final List<FeatureDefinition> features;
-
-    @JsonCreator
-    private VersionedFeatures(@JsonProperty("features") List<FeatureDefinition> features) {
-      this.features = features;
-    }
-  }
-
-  static class FeatureDefinition {
-    private final String name;
-    private final List<StrategyDefinition> strategies;
-
-    @JsonCreator
-    FeatureDefinition(
-        @JsonProperty("name") String name,
-        @JsonProperty("strategies") List<StrategyDefinition> strategies) {
-      this.name = name;
-      this.strategies = strategies;
-    }
-  }
-
   static class StrategyDefinition {
     private final String name;
     private final Map<String, String> parameters;
 
-    @JsonCreator
-    StrategyDefinition(
-        @JsonProperty("name") String name,
-        @JsonProperty("parameters") Map<String, String> parameters) {
+    StrategyDefinition(String name, Map<String, String> parameters) {
       this.name = name;
       this.parameters = parameters;
     }

java-engine/src/main/java/io/getunleash/engine/FlatInterface.java

@@ -25,10 +25,11 @@ public void freeEngine() {
 
   @Override
   public TakeStateResponse takeState(String toggles) {
-    UnleashFFI.Buf.ByValue buf = this.unleashFFI.takeState(enginePointer, toUtf8Pointer(toggles));
+    UnleashFFI.Buf.ByValue buf = this.unleashFFI.flatTakeState(enginePointer, toUtf8Pointer(toggles));
       long len = buf.len.longValue();
       byte[] out = buf.ptr.getByteArray(0, (int) len);
-    TakeStateResponse
+      this.unleashFFI.flatBufFree(buf);
+      return TakeStateResponse.getRootAsTakeStateResponse(ByteBuffer.wrap(out));
   }
 
   @Override

java-engine/src/main/java/io/getunleash/engine/UnleashEngine.java

@@ -41,10 +41,10 @@ public UnleashEngine(List<IStrategy> customStrategies, IStrategy fallbackStrateg
       List<String> builtInStrategies = getBuiltInStrategies();
       this.customStrategiesEvaluator =
           new CustomStrategiesEvaluator(
-              customStrategies.stream(), fallbackStrategy, new HashSet<String>(builtInStrategies));
+              customStrategies.stream(), fallbackStrategy, new HashSet<>(builtInStrategies));
     } else {
       this.customStrategiesEvaluator =
-          new CustomStrategiesEvaluator(Stream.empty(), fallbackStrategy, new HashSet<String>());
+          new CustomStrategiesEvaluator(Stream.empty(), fallbackStrategy, new HashSet<>());
     }
 
     cleaner.register(this, nativeEngine::freeEngine);
@@ -161,8 +161,8 @@ private static ByteBuffer buildMessage(
 
   public void takeState(String clientFeatures) throws YggdrasilInvalidInputException {
     try {
-      customStrategiesEvaluator.loadStrategiesFor(clientFeatures);
-      this.nativeEngine.takeState(clientFeatures);
+        TakeStateResponse takeStateResponse = this.nativeEngine.takeState(clientFeatures);
+        customStrategiesEvaluator.loadStrategiesFor(takeStateResponse);
     } catch (RuntimeException e) {
       throw new YggdrasilInvalidInputException("Failed to take state:", e);
     }
@@ -235,7 +235,7 @@ public List<String> getBuiltInStrategies() {
       }
       return builtInStrategiesNames;
     } else {
-      return List.of();
+      return Collections.emptyList();
     }
   }
 

java-engine/src/main/java/io/getunleash/engine/UnleashFFI.java

@@ -14,7 +14,7 @@ public interface UnleashFFI extends Library {
 
   void freeEngine(Pointer enginePointer);
 
-  UnleashFFI.Buf.ByValue takeState(Pointer enginePointer, Pointer toggles);
+  UnleashFFI.Buf.ByValue flatTakeState(Pointer enginePointer, Pointer toggles);
 
   Pointer getState(Pointer enginePointer);
 

java-engine/src/main/java/io/getunleash/messaging/BuiltInStrategies.java

@@ -21,7 +21,7 @@
 
 @SuppressWarnings("unused")
 public final class BuiltInStrategies extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_25_9_23(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_25_2_10(); }
   public static BuiltInStrategies getRootAsBuiltInStrategies(ByteBuffer _bb) { return getRootAsBuiltInStrategies(_bb, new BuiltInStrategies()); }
   public static BuiltInStrategies getRootAsBuiltInStrategies(ByteBuffer _bb, BuiltInStrategies obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

java-engine/src/main/java/io/getunleash/messaging/ContextMessage.java

@@ -21,7 +21,7 @@
 
 @SuppressWarnings("unused")
 public final class ContextMessage extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_25_9_23(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_25_2_10(); }
   public static ContextMessage getRootAsContextMessage(ByteBuffer _bb) { return getRootAsContextMessage(_bb, new ContextMessage()); }
   public static ContextMessage getRootAsContextMessage(ByteBuffer _bb, ContextMessage obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

java-engine/src/main/java/io/getunleash/messaging/CoreVersion.java

@@ -21,7 +21,7 @@
 
 @SuppressWarnings("unused")
 public final class CoreVersion extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_25_9_23(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_25_2_10(); }
   public static CoreVersion getRootAsCoreVersion(ByteBuffer _bb) { return getRootAsCoreVersion(_bb, new CoreVersion()); }
   public static CoreVersion getRootAsCoreVersion(ByteBuffer _bb, CoreVersion obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

java-engine/src/main/java/io/getunleash/messaging/CustomStrategyResult.java

@@ -21,7 +21,7 @@
 
 @SuppressWarnings("unused")
 public final class CustomStrategyResult extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_25_9_23(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_25_2_10(); }
   public static CustomStrategyResult getRootAsCustomStrategyResult(ByteBuffer _bb) { return getRootAsCustomStrategyResult(_bb, new CustomStrategyResult()); }
   public static CustomStrategyResult getRootAsCustomStrategyResult(ByteBuffer _bb, CustomStrategyResult obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }