feat: new provider

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/Config.java

@@ -40,6 +40,7 @@ public final class Config {
 
     static final String RESOLVER_RPC = "rpc";
     static final String RESOLVER_IN_PROCESS = "in-process";
+    static final String RESOLVER_FILE = "file";
 
     public static final String STATIC_REASON = "STATIC";
     public static final String CACHED_REASON = "CACHED";
@@ -87,6 +88,8 @@ static Resolver fromValueProvider(Function<String, String> provider) {
                 return Resolver.IN_PROCESS;
             case "rpc":
                 return Resolver.RPC;
+            case "file":
+                return Resolver.FILE;
             default:
                 log.warn("Unsupported resolver variable: {}", resolverVar);
                 return DEFAULT_RESOLVER_TYPE;
@@ -143,6 +146,11 @@ public String asString() {
             public String asString() {
                 return RESOLVER_IN_PROCESS;
             }
+        },
+        FILE {
+            public String asString() {
+                return RESOLVER_FILE;
+            }
         }
     }
 }

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java

@@ -119,8 +119,7 @@ public class FlagdOptions {
      * File source of flags to be used by offline mode.
      * Setting this enables the offline mode of the in-process provider.
      */
-    @Builder.Default
-    private String offlineFlagSourcePath = fallBackToEnvOrDefault(Config.OFFLINE_SOURCE_PATH, null);
+    private String offlineFlagSourcePath;
 
     /**
      * gRPC custom target string.
@@ -193,7 +192,19 @@ void prebuild() {
                 resolverType = fromValueProvider(System::getenv);
             }
 
-            if (port == 0) {
+            if (offlineFlagSourcePath == null
+                    || offlineFlagSourcePath.isEmpty()) {
+                offlineFlagSourcePath = fallBackToEnvOrDefault(Config.OFFLINE_SOURCE_PATH, null);
+            }
+
+            if (offlineFlagSourcePath != null
+                    && !offlineFlagSourcePath.isEmpty()) {
+                resolverType = Config.Resolver.FILE;
+            } else if (resolverType == Config.Resolver.FILE) {
+                throw new IllegalArgumentException("Resolver Type 'FILE' requires a offlineFlagSourcePath");
+            }
+
+            if (port == 0 && resolverType != Config.Resolver.FILE) {
                 port = Integer.parseInt(
                         fallBackToEnvOrDefault(Config.PORT_ENV_VAR_NAME, determineDefaultPortForResolver()));
             }

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdProvider.java

@@ -82,6 +82,7 @@ public FlagdProvider() {
      */
     public FlagdProvider(final FlagdOptions options) {
         switch (options.getResolverType().asString()) {
+            case Config.RESOLVER_FILE:
             case Config.RESOLVER_IN_PROCESS:
                 this.flagResolver = new InProcessResolver(options, this::onProviderEvent);
                 break;

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/FlagdOptionsTest.java

@@ -76,7 +76,6 @@ void TestBuilderOptions() {
         assertEquals("lru", flagdOptions.getCacheType());
         assertEquals(100, flagdOptions.getMaxCacheSize());
         assertEquals("app=weatherApp", flagdOptions.getSelector());
-        assertEquals("some-path", flagdOptions.getOfflineFlagSourcePath());
         assertEquals(openTelemetry, flagdOptions.getOpenTelemetry());
         assertEquals(connector, flagdOptions.getCustomConnector());
         assertEquals(Resolver.IN_PROCESS, flagdOptions.getResolverType());

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunFileTest.java

@@ -0,0 +1,39 @@
+package dev.openfeature.contrib.providers.flagd.e2e;
+
+import dev.openfeature.contrib.providers.flagd.Config;
+import org.apache.logging.log4j.core.config.Order;
+import org.junit.platform.suite.api.BeforeSuite;
+import org.junit.platform.suite.api.ConfigurationParameter;
+import org.junit.platform.suite.api.ExcludeTags;
+import org.junit.platform.suite.api.IncludeEngines;
+import org.junit.platform.suite.api.IncludeTags;
+import org.junit.platform.suite.api.SelectDirectories;
+import org.junit.platform.suite.api.Suite;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
+import static io.cucumber.junit.platform.engine.Constants.OBJECT_FACTORY_PROPERTY_NAME;
+import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
+
+/**
+ * Class for running the reconnection tests for the RPC provider
+ */
+@Order(value = Integer.MAX_VALUE)
+@Suite
+@IncludeEngines("cucumber")
+@SelectDirectories("test-harness/gherkin")
+// if you want to run just one feature file, use the following line instead of @SelectDirectories
+// @SelectFile("test-harness/gherkin/connection.feature")
+@ConfigurationParameter(key = PLUGIN_PROPERTY_NAME, value = "pretty")
+@ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "dev.openfeature.contrib.providers.flagd.e2e.steps")
+@ConfigurationParameter(key = OBJECT_FACTORY_PROPERTY_NAME, value = "io.cucumber.picocontainer.PicoFactory")
+@IncludeTags("in-process")
+@ExcludeTags({"unixsocket", "targetURI", "reconnect", "customCert", "events"})
+@Testcontainers
+public class RunFileTest {
+
+    @BeforeSuite
+    public static void before() {
+        State.resolverType = Config.Resolver.FILE;
+    }
+}

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/ConfigSteps.java

@@ -87,15 +87,16 @@ public void the_option_of_type_should_have_the_value(String option, String type,
         }
 
         option = mapOptionNames(option);
-
-        assertThat(state.options).hasFieldOrPropertyWithValue(option, convert);
-
-        // Resetting env vars
-        for (Map.Entry<String, String> envVar : envVarsSet.entrySet()) {
-            if (envVar.getValue() == null) {
-                EnvironmentVariableUtils.clear(envVar.getKey());
-            } else {
-                EnvironmentVariableUtils.set(envVar.getKey(), envVar.getValue());
+        try {
+            assertThat(state.options).hasFieldOrPropertyWithValue(option, convert);
+        } finally {
+            // Resetting env vars
+            for (Map.Entry<String, String> envVar : envVarsSet.entrySet()) {
+                if (envVar.getValue() == null) {
+                    EnvironmentVariableUtils.clear(envVar.getKey());
+                } else {
+                    EnvironmentVariableUtils.set(envVar.getKey(), envVar.getValue());
+                }
             }
         }
     }

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/ProviderSteps.java

@@ -134,6 +134,8 @@ public int getPort(Config.Resolver resolver, ProviderType providerType) {
                     case SSL:
                         return toxiproxy.getMappedPort(8669);
                 }
+            case FILE:
+                return 0;
             default:
                 throw new IllegalArgumentException("Unsupported resolver: " + resolver);
         }
@@ -143,10 +145,24 @@ public int getPort(Config.Resolver resolver, ProviderType providerType) {
     public void setupProvider(String providerType) throws IOException {
         state.builder.deadline(500).keepAlive(0).retryGracePeriod(3);
         boolean wait = true;
+        File flags = new File("test-harness/flags");
+        ObjectMapper objectMapper = new ObjectMapper();
+        Object merged = new Object();
+        for (File listFile : Objects.requireNonNull(flags.listFiles())) {
+            ObjectReader updater = objectMapper.readerForUpdating(merged);
+            merged = updater.readValue(listFile, Object.class);
+        }
+        Path offlinePath = Files.createTempFile("flags", ".json");
+        objectMapper.writeValue(offlinePath.toFile(), merged);
         switch (providerType) {
             case "unavailable":
                 this.state.providerType = ProviderType.SOCKET;
                 state.builder.port(UNAVAILABLE_PORT);
+                if (State.resolverType == Config.Resolver.FILE) {
+
+                    state.builder
+                            .offlineFlagSourcePath("not-existing");
+                }
                 wait = false;
                 break;
             case "socket":
@@ -167,25 +183,17 @@ public void setupProvider(String providerType) throws IOException {
                         .tls(true)
                         .certPath(absolutePath);
                 break;
-            case "offline":
-                File flags = new File("test-harness/flags");
-                ObjectMapper objectMapper = new ObjectMapper();
-                Object merged = new Object();
-                for (File listFile : Objects.requireNonNull(flags.listFiles())) {
-                    ObjectReader updater = objectMapper.readerForUpdating(merged);
-                    merged = updater.readValue(listFile, Object.class);
-                }
-                Path offlinePath = Files.createTempFile("flags", ".json");
-                objectMapper.writeValue(offlinePath.toFile(), merged);
-
-                state.builder
-                        .port(UNAVAILABLE_PORT)
-                        .offlineFlagSourcePath(offlinePath.toAbsolutePath().toString());
-                break;
 
             default:
                 this.state.providerType = ProviderType.DEFAULT;
-                state.builder.port(getPort(State.resolverType, state.providerType));
+                if (State.resolverType == Config.Resolver.FILE) {
+
+                    state.builder
+                            .port(UNAVAILABLE_PORT)
+                            .offlineFlagSourcePath(offlinePath.toAbsolutePath().toString());
+                } else {
+                    state.builder.port(getPort(State.resolverType, state.providerType));
+                }
                 break;
         }
         FeatureProvider provider =