feat: commonizes several FDv2 related types in Server

lib/sdk/server/build.gradle

@@ -71,7 +71,7 @@ ext.versions = [
     "guava": "32.0.1-jre",
     "jackson": "2.11.2",
     "launchdarklyJavaSdkCommon": "2.3.0",
-    "launchdarklyJavaSdkInternal": "1.7.0",
+    "launchdarklyJavaSdkInternal": "1.9.0",
     "launchdarklyLogging": "1.1.0",
     "okhttp": "4.12.0", // specify this for the SDK build instead of relying on the transitive dependency from okhttp-eventsource
     "okhttpEventsource": "4.2.0",
@@ -291,7 +291,7 @@ javadoc {
 // enclosing packages like "com" that don't have any classes in them.
 def getAllSdkPackages() {
     // base package classes come from launchdarkly-java-sdk-common
-    def names = [ "com.launchdarkly.sdk", "com.launchdarkly.sdk.json", "com.launchdarkly.logging" ]
+    def names = [ "com.launchdarkly.sdk", "com.launchdarkly.sdk.json", "com.launchdarkly.sdk.fdv2", "com.launchdarkly.logging" ]
     project.convention.getPlugin(JavaPluginConvention).sourceSets.main.output.each { baseDir ->
         if (baseDir.getPath().contains("classes" + File.separator + "java" + File.separator + "main")) {
             baseDir.eachFileRecurse { f ->

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/DataModelDependencies.java

@@ -6,8 +6,8 @@
 import com.google.common.collect.Iterables;
 import com.launchdarkly.sdk.LDValue;
 import com.launchdarkly.sdk.server.DataModel.Operator;
-import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ChangeSet;
-import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ChangeSetType;
+import com.launchdarkly.sdk.fdv2.ChangeSet;
+import com.launchdarkly.sdk.fdv2.ChangeSetType;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.DataKind;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.FullDataSet;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ItemDescriptor;
@@ -141,7 +141,10 @@ public static FullDataSet<ItemDescriptor> sortAllCollections(FullDataSet<ItemDes
    * @param inSet the changeset to sort
    * @return a sorted copy of the changeset
    */
-  public static ChangeSet<ItemDescriptor> sortChangeset(ChangeSet<ItemDescriptor> inSet) {
+  public static ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> sortChangeset(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> inSet) {
+    if (inSet.getData() == null) {
+      return inSet;
+    }
     ImmutableSortedMap.Builder<DataKind, KeyedItems<ItemDescriptor>> builder =
         ImmutableSortedMap.orderedBy(dataKindPriorityOrder);
     for (Map.Entry<DataKind, KeyedItems<ItemDescriptor>> entry: inSet.getData()) {

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/DataSourceSynchronizerAdapter.java

@@ -1,14 +1,19 @@
 package com.launchdarkly.sdk.server;
 
 import com.launchdarkly.sdk.internal.collections.IterableAsyncQueue;
-import com.launchdarkly.sdk.internal.fdv2.sources.Selector;
+import com.launchdarkly.sdk.fdv2.Selector;
 import com.launchdarkly.sdk.server.datasources.FDv2SourceResult;
 import com.launchdarkly.sdk.server.datasources.Synchronizer;
 import com.launchdarkly.sdk.server.interfaces.DataSourceStatusProvider;
 import com.launchdarkly.sdk.server.interfaces.DataStoreStatusProvider;
 import com.launchdarkly.sdk.server.subsystems.DataSource;
 import com.launchdarkly.sdk.server.subsystems.DataSourceUpdateSink;
+import com.launchdarkly.sdk.fdv2.ChangeSet;
+import com.launchdarkly.sdk.fdv2.ChangeSetType;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes;
+import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.DataKind;
+import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ItemDescriptor;
+import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.KeyedItems;
 
 import java.io.IOException;
 import java.time.Instant;
@@ -127,11 +132,11 @@ public ConvertingUpdateSink(IterableAsyncQueue<FDv2SourceResult> resultQueue) {
         }
 
         @Override
-        public boolean init(DataStoreTypes.FullDataSet<DataStoreTypes.ItemDescriptor> allData) {
+        public boolean init(DataStoreTypes.FullDataSet<ItemDescriptor> allData) {
             // Convert the full data set into a ChangeSet and emit it
-            DataStoreTypes.ChangeSet<DataStoreTypes.ItemDescriptor> changeSet =
-                    new DataStoreTypes.ChangeSet<>(
-                            DataStoreTypes.ChangeSetType.Full,
+            ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet =
+                    new ChangeSet<>(
+                            ChangeSetType.Full,
                             Selector.EMPTY,
                             allData.getData(),
                             null,
@@ -142,18 +147,18 @@ public boolean init(DataStoreTypes.FullDataSet<DataStoreTypes.ItemDescriptor> al
         }
 
         @Override
-        public boolean upsert(DataStoreTypes.DataKind kind, String key, DataStoreTypes.ItemDescriptor item) {
+        public boolean upsert(DataKind kind, String key, ItemDescriptor item) {
             // Convert the upsert into a ChangeSet with a single item and emit it
-            DataStoreTypes.KeyedItems<DataStoreTypes.ItemDescriptor> items =
-                    new DataStoreTypes.KeyedItems<>(Collections.<Map.Entry<String, DataStoreTypes.ItemDescriptor>>singletonList(
+            KeyedItems<ItemDescriptor> items =
+                    new KeyedItems<>(Collections.<Map.Entry<String, ItemDescriptor>>singletonList(
                             new AbstractMap.SimpleEntry<>(key, item)));
-            Iterable<Map.Entry<DataStoreTypes.DataKind, DataStoreTypes.KeyedItems<DataStoreTypes.ItemDescriptor>>> data =
-                    Collections.<Map.Entry<DataStoreTypes.DataKind, DataStoreTypes.KeyedItems<DataStoreTypes.ItemDescriptor>>>singletonList(
+            Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>> data =
+                    Collections.<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>singletonList(
                             new AbstractMap.SimpleEntry<>(kind, items));
 
-            DataStoreTypes.ChangeSet<DataStoreTypes.ItemDescriptor> changeSet =
-                    new DataStoreTypes.ChangeSet<>(
-                            DataStoreTypes.ChangeSetType.Partial,
+            ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet =
+                    new ChangeSet<>(
+                            ChangeSetType.Partial,
                             Selector.EMPTY,
                             data,
                             null,

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/DataSourceUpdatesImpl.java

@@ -14,7 +14,7 @@
 import com.launchdarkly.sdk.server.subsystems.DataSourceUpdateSink;
 import com.launchdarkly.sdk.server.subsystems.DataSourceUpdateSinkV2;
 import com.launchdarkly.sdk.server.subsystems.DataStore;
-import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ChangeSet;
+import com.launchdarkly.sdk.fdv2.ChangeSet;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.DataKind;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.FullDataSet;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ItemDescriptor;
@@ -370,7 +370,7 @@ private static String describeErrorCount(Map.Entry<ErrorInfo, Integer> entry) {
   }
 
   @Override
-  public boolean apply(ChangeSet<ItemDescriptor> changeSet) {
+  public boolean apply(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     if (store instanceof TransactionalDataStore) {
       return applyToTransactionalStore((TransactionalDataStore) store, changeSet);
     }
@@ -380,7 +380,7 @@ public boolean apply(ChangeSet<ItemDescriptor> changeSet) {
   }
 
   private boolean applyToTransactionalStore(TransactionalDataStore transactionalDataStore,
-      ChangeSet<ItemDescriptor> changeSet) {
+      ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     Map<DataKind, Map<String, ItemDescriptor>> oldData;
     // Getting the old values requires accessing the store, which can fail.
     // If there is a failure to read the store, then we stop treating it as a failure.
@@ -391,7 +391,7 @@ private boolean applyToTransactionalStore(TransactionalDataStore transactionalDa
       return false;
     }
 
-    ChangeSet<ItemDescriptor> sortedChangeSet = DataModelDependencies.sortChangeset(changeSet);
+    ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> sortedChangeSet = DataModelDependencies.sortChangeset(changeSet);
 
     try {
       transactionalDataStore.apply(sortedChangeSet);
@@ -415,7 +415,7 @@ private boolean applyToTransactionalStore(TransactionalDataStore transactionalDa
     return true;
   }
 
-  private boolean applyToLegacyStore(ChangeSet<ItemDescriptor> sortedChangeSet) {
+  private boolean applyToLegacyStore(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> sortedChangeSet) {
     switch (sortedChangeSet.getType()) {
       case Full:
         return applyFullChangeSetToLegacyStore(sortedChangeSet);
@@ -427,16 +427,16 @@ private boolean applyToLegacyStore(ChangeSet<ItemDescriptor> sortedChangeSet) {
     }
   }
 
-  private boolean applyFullChangeSetToLegacyStore(ChangeSet<ItemDescriptor> unsortedChangeset) {
+  private boolean applyFullChangeSetToLegacyStore(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> unsortedChangeset) {
     // Convert ChangeSet to FullDataSet for legacy init path, preserving shouldPersist flag
     return init(new FullDataSet<>(unsortedChangeset.getData(), unsortedChangeset.shouldPersist()));
   }
 
-  private boolean applyPartialChangeSetToLegacyStore(ChangeSet<ItemDescriptor> changeSet) {
+  private boolean applyPartialChangeSetToLegacyStore(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     // Sorting isn't strictly required here, as upsert behavior didn't traditionally have it,
     // but it also doesn't hurt, and there could be cases where it results in slightly
     // greater store consistency for persistent stores.
-    ChangeSet<ItemDescriptor> sortedChangeset = DataModelDependencies.sortChangeset(changeSet);
+    ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> sortedChangeset = DataModelDependencies.sortChangeset(changeSet);
 
     for (Map.Entry<DataKind, KeyedItems<ItemDescriptor>> kindItemsPair: sortedChangeset.getData()) {
       for (Map.Entry<String, ItemDescriptor> item: kindItemsPair.getValue().getItems()) {
@@ -471,7 +471,7 @@ private Map<DataKind, Map<String, ItemDescriptor>> getOldDataIfFlagChangeListene
     }
   }
 
-  private Map<DataKind, Map<String, ItemDescriptor>> changeSetToMap(ChangeSet<ItemDescriptor> changeSet) {
+  private Map<DataKind, Map<String, ItemDescriptor>> changeSetToMap(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     Map<DataKind, Map<String, ItemDescriptor>> ret = new HashMap<>();
     for (Map.Entry<DataKind, KeyedItems<ItemDescriptor>> e: changeSet.getData()) {
       ret.put(e.getKey(), ImmutableMap.copyOf(e.getValue().getItems()));
@@ -481,7 +481,7 @@ private Map<DataKind, Map<String, ItemDescriptor>> changeSetToMap(ChangeSet<Item
 
   private Set<KindAndKey> updateDependencyTrackerForChangesetAndDetermineChanges(
       Map<DataKind, Map<String, ItemDescriptor>> oldDataMap,
-      ChangeSet<ItemDescriptor> changeSet) {
+      ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     switch (changeSet.getType()) {
       case Full:
         return handleFullChangeset(oldDataMap, changeSet);
@@ -496,7 +496,7 @@ private Set<KindAndKey> updateDependencyTrackerForChangesetAndDetermineChanges(
 
   private Set<KindAndKey> handleFullChangeset(
       Map<DataKind, Map<String, ItemDescriptor>> oldDataMap,
-      ChangeSet<ItemDescriptor> changeSet) {
+      ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     dependencyTracker.reset();
     for (Map.Entry<DataKind, KeyedItems<ItemDescriptor>> kindEntry: changeSet.getData()) {
       DataKind kind = kindEntry.getKey();
@@ -516,7 +516,7 @@ private Set<KindAndKey> handleFullChangeset(
 
   private Set<KindAndKey> handlePartialChangeset(
       Map<DataKind, Map<String, ItemDescriptor>> oldDataMap,
-      ChangeSet<ItemDescriptor> changeSet) {
+      ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     if (oldDataMap == null) {
       // Update dependencies but don't track changes when no listeners
       for (Map.Entry<DataKind, KeyedItems<ItemDescriptor>> kindEntry: changeSet.getData()) {

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/DefaultFDv2Requestor.java

@@ -2,7 +2,7 @@
 
 import com.launchdarkly.logging.LDLogger;
 import com.launchdarkly.sdk.internal.fdv2.payloads.FDv2Event;
-import com.launchdarkly.sdk.internal.fdv2.sources.Selector;
+import com.launchdarkly.sdk.fdv2.Selector;
 import com.launchdarkly.sdk.internal.http.HttpHelpers;
 import com.launchdarkly.sdk.internal.http.HttpProperties;
 

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/FDv2ChangeSetTranslator.java

@@ -5,8 +5,9 @@
 import com.launchdarkly.sdk.internal.fdv2.sources.FDv2ChangeSet;
 import com.launchdarkly.sdk.internal.fdv2.sources.FDv2ChangeSet.FDv2Change;
 import com.launchdarkly.sdk.internal.fdv2.sources.FDv2ChangeSet.FDv2ChangeType;
+import com.launchdarkly.sdk.fdv2.ChangeSet;
+import com.launchdarkly.sdk.fdv2.ChangeSetType;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes;
-import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ChangeSetType;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.DataKind;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ItemDescriptor;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.KeyedItems;
@@ -25,16 +26,16 @@ private FDv2ChangeSetTranslator() {
     }
 
     /**
-     * Converts an FDv2ChangeSet to a DataStoreTypes.ChangeSet.
+     * Converts an FDv2ChangeSet to a ChangeSet.
      *
      * @param changeset     the FDv2 changeset to convert
      * @param logger        logger for diagnostic messages
      * @param environmentId the environment ID to include in the changeset (may be null)
      * @param shouldPersist true if the data should be persisted to persistent stores, false otherwise
-     * @return a DataStoreTypes.ChangeSet containing the converted data
+     * @return a ChangeSet containing the converted data
      * @throws IllegalArgumentException if the changeset type is unknown
      */
-    public static DataStoreTypes.ChangeSet<ItemDescriptor> toChangeSet(
+    public static ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> toChangeSet(
             FDv2ChangeSet changeset,
             LDLogger logger,
             String environmentId,
@@ -101,7 +102,7 @@ public static DataStoreTypes.ChangeSet<ItemDescriptor> toChangeSet(
                     ));
         }
 
-        return new DataStoreTypes.ChangeSet<>(
+        return new ChangeSet<>(
                 changeSetType,
                 changeset.getSelector(),
                 dataBuilder.build(),

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/FDv2DataSourceConditions.java

@@ -1,5 +1,7 @@
 package com.launchdarkly.sdk.server;
 
+import com.launchdarkly.sdk.fdv2.SourceResultType;
+import com.launchdarkly.sdk.fdv2.SourceSignal;
 import com.launchdarkly.sdk.server.datasources.FDv2SourceResult;
 
 import java.io.Closeable;
@@ -120,13 +122,13 @@ public FallbackCondition(ScheduledExecutorService sharedExecutor, long timeoutSe
 
         @Override
         public void inform(FDv2SourceResult sourceResult) {
-            if (sourceResult.getResultType() == FDv2SourceResult.ResultType.CHANGE_SET) {
+            if (sourceResult.getResultType() == SourceResultType.CHANGE_SET) {
                 if (timerFuture != null) {
                     timerFuture.cancel(false);
                     timerFuture = null;
                 }
             }
-            if (sourceResult.getResultType() == FDv2SourceResult.ResultType.STATUS && sourceResult.getStatus().getState() == FDv2SourceResult.State.INTERRUPTED) {
+            if (sourceResult.getResultType() == SourceResultType.STATUS && sourceResult.getStatus().getState() == SourceSignal.INTERRUPTED) {
                 if (timerFuture == null) {
                     timerFuture = sharedExecutor.schedule(() -> {
                         resultFuture.complete(this);

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/FDv2Requestor.java

@@ -1,7 +1,7 @@
 package com.launchdarkly.sdk.server;
 
 import com.launchdarkly.sdk.internal.fdv2.payloads.FDv2Event;
-import com.launchdarkly.sdk.internal.fdv2.sources.Selector;
+import com.launchdarkly.sdk.fdv2.Selector;
 import okhttp3.Headers;
 
 import java.util.List;

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/InMemoryDataStore.java

@@ -2,11 +2,11 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.launchdarkly.sdk.internal.fdv2.sources.Selector;
+import com.launchdarkly.sdk.fdv2.Selector;
 import com.launchdarkly.sdk.server.interfaces.DataStoreStatusProvider.CacheStats;
 import com.launchdarkly.sdk.server.subsystems.DataStore;
-import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ChangeSet;
-import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ChangeSetType;
+import com.launchdarkly.sdk.fdv2.ChangeSet;
+import com.launchdarkly.sdk.fdv2.ChangeSetType;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.DataKind;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.FullDataSet;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ItemDescriptor;
@@ -122,7 +122,7 @@ public void close() throws IOException {
   }
 
   @Override
-  public void apply(ChangeSet<ItemDescriptor> changeSet) {
+  public void apply(ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> changeSet) {
     switch (changeSet.getType()) {
       case Full:
         applyFullPayload(changeSet.getData(), changeSet.getEnvironmentId(), changeSet.getSelector(), changeSet.shouldPersist());

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/PollingBase.java

@@ -3,13 +3,20 @@
 import com.launchdarkly.logging.LDLogger;
 import com.launchdarkly.sdk.internal.fdv2.payloads.FDv2Event;
 import com.launchdarkly.sdk.internal.fdv2.sources.FDv2ProtocolHandler;
-import com.launchdarkly.sdk.internal.fdv2.sources.Selector;
+import com.launchdarkly.sdk.fdv2.Selector;
 import com.launchdarkly.sdk.server.datasources.FDv2SourceResult;
 import com.launchdarkly.sdk.server.interfaces.DataSourceStatusProvider;
+import com.launchdarkly.sdk.fdv2.ChangeSet;
+import com.launchdarkly.sdk.fdv2.ChangeSetType;
 import com.launchdarkly.sdk.server.subsystems.DataStoreTypes;
+import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.DataKind;
+import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.ItemDescriptor;
+import com.launchdarkly.sdk.server.subsystems.DataStoreTypes.KeyedItems;
 import com.launchdarkly.sdk.json.SerializationException;
 
 import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
 import java.util.Date;
 import java.util.concurrent.CompletableFuture;
 
@@ -83,9 +90,9 @@ protected CompletableFuture<FDv2SourceResult> poll(Selector selector, boolean on
             // If we get a 304, then that means nothing has changed.
             if (pollingResponse.getStatusCode() == 304) {
                 return FDv2SourceResult.changeSet(
-                        new DataStoreTypes.ChangeSet<>(DataStoreTypes.ChangeSetType.None,
+                        new ChangeSet<>(ChangeSetType.None,
                                 Selector.EMPTY,
-                                null,
+                                Collections.emptyList(),
                                 null, // Header derived values will have been handled on initial response.
                                 true // Polling data from LaunchDarkly should be persisted
                         ),
@@ -111,7 +118,7 @@ protected CompletableFuture<FDv2SourceResult> poll(Selector selector, boolean on
                     case CHANGESET:
                         try {
 
-                            DataStoreTypes.ChangeSet<DataStoreTypes.ItemDescriptor> converted = FDv2ChangeSetTranslator.toChangeSet(
+                            ChangeSet<Iterable<Map.Entry<DataKind, KeyedItems<ItemDescriptor>>>> converted = FDv2ChangeSetTranslator.toChangeSet(
                                     ((FDv2ProtocolHandler.FDv2ActionChangeset) res).getChangeset(),
                                     logger,
                                     environmentId,

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/SelectorSourceFacade.java

@@ -1,6 +1,6 @@
 package com.launchdarkly.sdk.server;
 
-import com.launchdarkly.sdk.internal.fdv2.sources.Selector;
+import com.launchdarkly.sdk.fdv2.Selector;
 import com.launchdarkly.sdk.server.datasources.SelectorSource;
 import com.launchdarkly.sdk.server.subsystems.TransactionalDataStore;