* If you need to specify any configuration use {@link Provider#Provider(String, LDConfig)} instead. + * Initialization waits indefinitely; using {@link Provider#Provider(String, LDConfig, Duration)} with a non-zero + * duration is strongly recommended. * * @param sdkKey the SDK key for your LaunchDarkly environment */ public Provider(String sdkKey) { - this(sdkKey, new LDConfig.Builder().build()); + this(new LDClient(sdkKey, withWrapper(new LDConfig.Builder().build())), Duration.ZERO); } /** - * Crate a provider with the specified SDK key and configuration. + * Create a provider with the specified SDK key and configuration. + * Initialization waits indefinitely; using {@link Provider#Provider(String, LDConfig, Duration)} with a non-zero + * duration is strongly recommended. * * @param sdkKey the SDK key for your LaunchDarkly environment - * @param config a client configuration object + * @param config a client configuration object; its start wait setting is preserved, and provider initialization + * waits indefinitely */ public Provider(String sdkKey, LDConfig config) { - this(new LDClient(sdkKey, LDConfig.Builder.fromConfig(config) + this(new LDClient(sdkKey, withWrapper(config)), Duration.ZERO); + } + + /** + * Create a provider with the specified SDK key, configuration, and start wait duration. + *
+ * The duration is applied to the LaunchDarkly SDK as its start wait, and it bounds the whole of initialization: + * the constructor blocks for up to that long, and initialization then reports that outcome rather than waiting + * again. A non-zero duration is strongly recommended. A duration of zero applies no deadline: the constructor does + * not block, and initialization waits until the LaunchDarkly data source becomes valid or fails permanently, which + * may be indefinitely. + *
+ * When the provider is registered with {@code setProviderAndWait}, initialization runs on the calling thread, so
+ * that call blocks for up to the duration and throws if the client did not become ready. When it is registered
+ * with {@code setProvider}, initialization runs in the background and a failure is reported as a
+ * {@code PROVIDER_ERROR} event instead, with evaluations before readiness returning their default value.
+ *
+ * @param sdkKey the SDK key for your LaunchDarkly environment
+ * @param config a client configuration object
+ * @param startWait the maximum duration to wait for initialization; zero applies no deadline
+ */
+ public Provider(String sdkKey, LDConfig config, Duration startWait) {
+ this(new LDClient(sdkKey,
+ withWrapper(LDConfig.Builder.fromConfig(config).startWait(startWait).build())), startWait);
+ }
+
+ private static LDConfig withWrapper(LDConfig config) {
+ return LDConfig.Builder.fromConfig(config)
.wrapper(Components.wrapperInfo()
.wrapperName("open-feature-java-server")
- .wrapperVersion(Version.SDK_VERSION)).build()));
+ .wrapperVersion(Version.SDK_VERSION)).build();
}
Provider(LDClientInterface client) {
+ this(client, Duration.ZERO);
+ }
+
+ Provider(LDClientInterface client, Duration startWait) {
this.client = client;
+ this.startWait = startWait;
logger = client.getLogger();
evaluationContextConverter = new EvaluationContextConverter(logger);
evaluationDetailConverter = new EvaluationDetailConverter(logger);
@@ -174,12 +213,19 @@ public void initialize(EvaluationContext evaluationContext) throws Exception {
boolean successfullyInitialized;
try {
handleDataSourceStatus(client.getDataSourceStatusProvider().getStatus(), completer);
+
+ // With a start wait the client constructor has already waited, so the data source has either become valid,
+ // failed permanently, or run out of time; the outcome is whatever it is now.
+ if (!startWait.isZero() && !completer.isDone()) {
+ setState(ProviderState.ERROR);
+ throw new RuntimeException("The client did not initialize within the start wait duration.");
+ }
successfullyInitialized = completer.get();
} finally {
setInitializing(false);
}
- if(!successfullyInitialized) {
+ if (!successfullyInitialized) {
throw new RuntimeException("Failed to initialize LaunchDarkly client.");
}
}
diff --git a/src/test/java/com/launchdarkly/openfeature/serverprovider/LifeCycleTest.java b/src/test/java/com/launchdarkly/openfeature/serverprovider/LifeCycleTest.java
index 929b204..9a8133c 100644
--- a/src/test/java/com/launchdarkly/openfeature/serverprovider/LifeCycleTest.java
+++ b/src/test/java/com/launchdarkly/openfeature/serverprovider/LifeCycleTest.java
@@ -32,6 +32,8 @@
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
import static org.junit.jupiter.api.Assertions.assertTrue;
class DelayedDataSource implements DataSource {
@@ -159,6 +161,26 @@ public DataSource build(ClientContext clientContext) {
}
}
+class NeverReadyDataSource implements DataSource {
+ public Future
@@ -200,6 +222,19 @@ public void canShutdownAnOfflineClient() {
});
}
+ @Test
+ public void twoArgumentConstructorPreservesConfigStartWait() {
+ assertTimeoutPreemptively(Duration.ofSeconds(1), () -> {
+ var config = new LDConfig.Builder()
+ .startWait(Duration.ZERO)
+ .dataSource(new NeverReadyDataSourceFactory())
+ .events(Components.noEvents())
+ .build();
+ var provider = new Provider("fake-key", config);
+ provider.shutdown();
+ });
+ }
+
@Test
public void itEmitsReadyEvents() throws ExecutionException, InterruptedException, TimeoutException {
var provider = new Provider("fake-key", new LDConfig.Builder()
@@ -288,6 +323,77 @@ public void itCanHandleClientThatIsNotInitializedImmediatelyAndErrors() throws E
assertTrue(gotErrorEvent.get(1000, TimeUnit.MILLISECONDS));
}
+ @Test
+ public void initializationFailsWithoutWaitingAgainWhenStartWaitIsPositive() {
+ assertTimeoutPreemptively(Duration.ofSeconds(1), () -> {
+ var config = new LDConfig.Builder()
+ .dataSource(new NeverReadyDataSourceFactory())
+ .events(Components.noEvents())
+ .build();
+ var provider = new Provider("fake-key", config, Duration.ofMillis(300));
+ try {
+ // The constructor consumed the start wait, so initialization must not wait a second time.
+ assertTimeoutPreemptively(Duration.ofMillis(100), () -> {
+ var error = assertThrows(RuntimeException.class,
+ () -> provider.initialize(new ImmutableContext("context-key")));
+ assertTrue(error.getMessage()
+ .contains("The client did not initialize within the start wait duration."));
+ });
+ assertEquals(ProviderState.ERROR, provider.getState());
+ } finally {
+ provider.shutdown();
+ }
+ });
+ }
+
+ @Test
+ public void initializationSucceedsWhenTheClientBecomesReadyDuringTheStartWait() {
+ assertTimeoutPreemptively(Duration.ofSeconds(1), () -> {
+ var config = new LDConfig.Builder()
+ .dataSource(new DelayedDataSourceFactory(Duration.ofMillis(100), false))
+ .events(Components.noEvents())
+ .build();
+ var provider = new Provider("fake-key", config, Duration.ofMillis(500));
+ try {
+ assertDoesNotThrow(() -> provider.initialize(new ImmutableContext("context-key")));
+ assertEquals(ProviderState.READY, provider.getState());
+ } finally {
+ provider.shutdown();
+ }
+ });
+ }
+
+ @Test
+ public void initializationReportsPermanentFailureAfterAPositiveStartWait() {
+ assertTimeoutPreemptively(Duration.ofSeconds(1), () -> {
+ var config = new LDConfig.Builder()
+ .dataSource(new DelayedDataSourceFactory(Duration.ofMillis(100), true))
+ .events(Components.noEvents())
+ .build();
+ var provider = new Provider("fake-key", config, Duration.ofMillis(500));
+ try {
+ var error = assertThrows(RuntimeException.class,
+ () -> provider.initialize(new ImmutableContext("context-key")));
+ assertEquals("Failed to initialize LaunchDarkly client.", error.getMessage());
+ } finally {
+ provider.shutdown();
+ }
+ });
+ }
+
+ @Test
+ public void initializationWaitsIndefinitelyWhenStartWaitIsZero() throws Exception {
+ var config = new LDConfig.Builder()
+ .dataSource(new DelayedDataSourceFactory(Duration.ofMillis(200), false))
+ .events(Components.noEvents())
+ .build();
+ var provider = new Provider("fake-key", config, Duration.ZERO);
+
+ assertDoesNotThrow(() -> provider.initialize(new ImmutableContext("context-key")));
+ assertEquals(ProviderState.READY, provider.getState());
+ provider.shutdown();
+ }
+
@Test
public void itEmitsReadyWhenTheDataSourceRecoversFromAFailedInitialization() throws Exception {
var dataSourceFactory = new ControllableDataSourceFactory();