diff --git a/build.gradle b/build.gradle
index 8ceecad3..a02b9d4f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -61,5 +61,5 @@ dependencies {
task wrapper(type: Wrapper) {
gradleVersion = '4.0'
- distributionUrl = "http://services.gradle.org/distributions/gradle-4.0-all.zip"
+ distributionUrl = "https://services.gradle.org/distributions/gradle-4.0-all.zip"
}
diff --git a/gradle/publishing.gradle b/gradle/publishing.gradle
index 3b39c43a..dddb55f4 100644
--- a/gradle/publishing.gradle
+++ b/gradle/publishing.gradle
@@ -4,7 +4,7 @@ apply plugin: 'com.jfrog.bintray'
publishing {
repositories {
maven {
- url 'http://dl.bintray.com/bbakerman/java-dataloader'
+ url 'https://dl.bintray.com/bbakerman/java-dataloader'
}
}
}
@@ -52,7 +52,7 @@ publishing {
licenses {
license {
name 'The Apache Software License, Version 2.0'
- url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+ url 'https://www.apache.org/licenses/LICENSE-2.0.txt'
distribution 'repo'
}
}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index c2194cef..9a4bafb5 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-4.0-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.0-all.zip
diff --git a/src/main/java/org/dataloader/BatchLoader.java b/src/main/java/org/dataloader/BatchLoader.java
index 6780f568..aee9df2c 100644
--- a/src/main/java/org/dataloader/BatchLoader.java
+++ b/src/main/java/org/dataloader/BatchLoader.java
@@ -71,6 +71,7 @@
* @author Brad Baker
*/
@FunctionalInterface
+@PublicSpi
public interface BatchLoader {
/**
diff --git a/src/main/java/org/dataloader/BatchLoaderContextProvider.java b/src/main/java/org/dataloader/BatchLoaderContextProvider.java
index b32c3f0d..0eda7ccd 100644
--- a/src/main/java/org/dataloader/BatchLoaderContextProvider.java
+++ b/src/main/java/org/dataloader/BatchLoaderContextProvider.java
@@ -5,6 +5,7 @@
* provide overall calling context to the {@link org.dataloader.BatchLoader} call. A common use
* case is for propagating user security credentials or database connection parameters for example.
*/
+@PublicSpi
public interface BatchLoaderContextProvider {
/**
* @return a context object that may be needed in batch load calls
diff --git a/src/main/java/org/dataloader/BatchLoaderEnvironment.java b/src/main/java/org/dataloader/BatchLoaderEnvironment.java
index 5aa4a350..096c05a8 100644
--- a/src/main/java/org/dataloader/BatchLoaderEnvironment.java
+++ b/src/main/java/org/dataloader/BatchLoaderEnvironment.java
@@ -12,6 +12,7 @@
* This object is passed to a batch loader as calling context. It could contain security credentials
* of the calling users for example or database parameters that allow the data layer call to succeed.
*/
+@PublicApi
public class BatchLoaderEnvironment {
private final Object context;
diff --git a/src/main/java/org/dataloader/BatchLoaderEnvironmentProvider.java b/src/main/java/org/dataloader/BatchLoaderEnvironmentProvider.java
index b614e248..66d46c1b 100644
--- a/src/main/java/org/dataloader/BatchLoaderEnvironmentProvider.java
+++ b/src/main/java/org/dataloader/BatchLoaderEnvironmentProvider.java
@@ -6,6 +6,7 @@
* the {@link org.dataloader.BatchLoader} call. A common use
* case is for propagating user security credentials or database connection parameters.
*/
+@PublicSpi
public interface BatchLoaderEnvironmentProvider {
/**
* @return a {@link org.dataloader.BatchLoaderEnvironment} that may be needed in batch calls
diff --git a/src/main/java/org/dataloader/BatchLoaderWithContext.java b/src/main/java/org/dataloader/BatchLoaderWithContext.java
index e287d90d..b82a63f2 100644
--- a/src/main/java/org/dataloader/BatchLoaderWithContext.java
+++ b/src/main/java/org/dataloader/BatchLoaderWithContext.java
@@ -11,6 +11,7 @@
* See {@link org.dataloader.BatchLoader} for more details on the design invariants that you must implement in order to
* use this interface.
*/
+@PublicSpi
public interface BatchLoaderWithContext {
/**
* Called to batch load the provided keys and return a promise to a list of values. This default
diff --git a/src/main/java/org/dataloader/CacheMap.java b/src/main/java/org/dataloader/CacheMap.java
index 2aa792e3..f60c6ef5 100644
--- a/src/main/java/org/dataloader/CacheMap.java
+++ b/src/main/java/org/dataloader/CacheMap.java
@@ -35,6 +35,7 @@
* @author Arnold Schrijver
* @author Brad Baker
*/
+@PublicSpi
public interface CacheMap {
/**
diff --git a/src/main/java/org/dataloader/DataLoader.java b/src/main/java/org/dataloader/DataLoader.java
index cef34764..a0880709 100644
--- a/src/main/java/org/dataloader/DataLoader.java
+++ b/src/main/java/org/dataloader/DataLoader.java
@@ -54,6 +54,7 @@
* @author Arnold Schrijver
* @author Brad Baker
*/
+@PublicApi
public class DataLoader {
private final DataLoaderHelper helper;
@@ -470,7 +471,7 @@ public CompletableFuture> loadMany(List keys, List keyContext
* @return the promise of the queued load requests
*/
public CompletableFuture> dispatch() {
- return helper.dispatch().futureList;
+ return helper.dispatch().getPromisedResults();
}
/**
@@ -480,9 +481,9 @@ public CompletableFuture> dispatch() {
* If batching is disabled, or there are no queued requests, then a succeeded promise with no entries dispatched is
* returned.
*
- * @return the promise of the queued load requests and the number of entries dispatched.
+ * @return the promise of the queued load requests and the number of keys dispatched.
*/
- public DataLoaderHelper.DispatchResult dispatchWithCounts() {
+ public DispatchResult dispatchWithCounts() {
return helper.dispatch();
}
diff --git a/src/main/java/org/dataloader/DataLoaderHelper.java b/src/main/java/org/dataloader/DataLoaderHelper.java
index d3fbd84c..f2437bef 100644
--- a/src/main/java/org/dataloader/DataLoaderHelper.java
+++ b/src/main/java/org/dataloader/DataLoaderHelper.java
@@ -26,6 +26,7 @@
* @param the type of keys
* @param the type of values
*/
+@Internal
class DataLoaderHelper {
@@ -134,15 +135,6 @@ Object getCacheKey(K key) {
loaderOptions.cacheKeyFunction().get().getKey(key) : key;
}
- public static class DispatchResult {
- public final CompletableFuture> futureList;
- public final int totalEntriesHandled;
- public DispatchResult(CompletableFuture> futureList, int totalEntriesHandled) {
- this.futureList = futureList;
- this.totalEntriesHandled = totalEntriesHandled;
- }
- }
-
DispatchResult dispatch() {
boolean batchingEnabled = loaderOptions.batchingEnabled();
//
diff --git a/src/main/java/org/dataloader/DataLoaderOptions.java b/src/main/java/org/dataloader/DataLoaderOptions.java
index 48d0478c..8158902e 100644
--- a/src/main/java/org/dataloader/DataLoaderOptions.java
+++ b/src/main/java/org/dataloader/DataLoaderOptions.java
@@ -29,6 +29,7 @@
*
* @author Arnold Schrijver
*/
+@PublicApi
public class DataLoaderOptions {
private static final BatchLoaderContextProvider NULL_PROVIDER = () -> null;
diff --git a/src/main/java/org/dataloader/DataLoaderRegistry.java b/src/main/java/org/dataloader/DataLoaderRegistry.java
index 3b0e719c..bf9b2c62 100644
--- a/src/main/java/org/dataloader/DataLoaderRegistry.java
+++ b/src/main/java/org/dataloader/DataLoaderRegistry.java
@@ -15,6 +15,7 @@
* they can be dispatched as one. It also allows you to retrieve data loaders by
* name from a central place
*/
+@PublicApi
public class DataLoaderRegistry {
private final Map> dataLoaders = new ConcurrentHashMap<>();
@@ -118,8 +119,8 @@ public void dispatchAll() {
*/
public int dispatchAllWithCount() {
int sum = 0;
- for (DataLoader dataLoader : getDataLoaders()) {
- sum += dataLoader.dispatchWithCounts().totalEntriesHandled;
+ for (DataLoader,?> dataLoader : getDataLoaders()) {
+ sum += dataLoader.dispatchWithCounts().getKeysCount();
}
return sum;
}
diff --git a/src/main/java/org/dataloader/DispatchResult.java b/src/main/java/org/dataloader/DispatchResult.java
new file mode 100644
index 00000000..c1b41aae
--- /dev/null
+++ b/src/main/java/org/dataloader/DispatchResult.java
@@ -0,0 +1,29 @@
+package org.dataloader;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * When a DataLoader is dispatched this object holds the promised results and also the count of key asked for
+ * via methods like {@link org.dataloader.DataLoader#load(Object)} or {@link org.dataloader.DataLoader#loadMany(java.util.List)}
+ *
+ * @param for two
+ */
+@PublicApi
+public class DispatchResult {
+ private final CompletableFuture> futureList;
+ private final int keysCount;
+
+ public DispatchResult(CompletableFuture> futureList, int keysCount) {
+ this.futureList = futureList;
+ this.keysCount = keysCount;
+ }
+
+ public CompletableFuture> getPromisedResults() {
+ return futureList;
+ }
+
+ public int getKeysCount() {
+ return keysCount;
+ }
+}
diff --git a/src/main/java/org/dataloader/Internal.java b/src/main/java/org/dataloader/Internal.java
new file mode 100644
index 00000000..736c0331
--- /dev/null
+++ b/src/main/java/org/dataloader/Internal.java
@@ -0,0 +1,21 @@
+package org.dataloader;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+/**
+ * This represents code that the java-dataloader project considers internal code that MAY not be stable within
+ * major releases.
+ *
+ * In general unnecessary changes will be avoided but you should not depend on internal classes being stable
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = {CONSTRUCTOR, METHOD, TYPE, FIELD})
+public @interface Internal {
+}
diff --git a/src/main/java/org/dataloader/PublicApi.java b/src/main/java/org/dataloader/PublicApi.java
new file mode 100644
index 00000000..d2472e9f
--- /dev/null
+++ b/src/main/java/org/dataloader/PublicApi.java
@@ -0,0 +1,24 @@
+package org.dataloader;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+/**
+ * This represents code that the java-dataloader project considers public API and has an imperative to be stable within
+ * major releases.
+ *
+ * The guarantee is for code calling classes and interfaces with this annotation, not derived from them. New methods
+ * maybe be added which would break derivations but not callers.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = {CONSTRUCTOR, METHOD, TYPE, FIELD})
+@Documented
+public @interface PublicApi {
+}
diff --git a/src/main/java/org/dataloader/PublicSpi.java b/src/main/java/org/dataloader/PublicSpi.java
new file mode 100644
index 00000000..86a43e9c
--- /dev/null
+++ b/src/main/java/org/dataloader/PublicSpi.java
@@ -0,0 +1,25 @@
+package org.dataloader;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+/**
+ * This represents code that the java-dataloader project considers public SPI and has an imperative to be stable within
+ * major releases.
+ *
+ * The guarantee is for callers of code with this annotation as well as derivations that inherit / implement this code.
+ *
+ * New methods will not be added (without using default methods say) that would nominally breaks SPI implementations
+ * within a major release.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = {CONSTRUCTOR, METHOD, TYPE})
+@Documented
+public @interface PublicSpi {
+}
diff --git a/src/main/java/org/dataloader/Try.java b/src/main/java/org/dataloader/Try.java
index 38ad739b..6a7f44ec 100644
--- a/src/main/java/org/dataloader/Try.java
+++ b/src/main/java/org/dataloader/Try.java
@@ -22,6 +22,7 @@
* {@link org.dataloader.DataLoader} understands the use of Try and will take the exceptional path and complete
* the value promise with that exception value.
*/
+@PublicApi
public class Try {
private static Throwable NIL = new Throwable() {
@Override
diff --git a/src/main/java/org/dataloader/impl/Assertions.java b/src/main/java/org/dataloader/impl/Assertions.java
index ad1a1ef9..3b098143 100644
--- a/src/main/java/org/dataloader/impl/Assertions.java
+++ b/src/main/java/org/dataloader/impl/Assertions.java
@@ -1,7 +1,10 @@
package org.dataloader.impl;
+import org.dataloader.Internal;
+
import java.util.Objects;
+@Internal
public class Assertions {
public static void assertState(boolean state, String message) {
diff --git a/src/main/java/org/dataloader/impl/CompletableFutureKit.java b/src/main/java/org/dataloader/impl/CompletableFutureKit.java
index 53deab1f..d4b9f79b 100644
--- a/src/main/java/org/dataloader/impl/CompletableFutureKit.java
+++ b/src/main/java/org/dataloader/impl/CompletableFutureKit.java
@@ -1,5 +1,7 @@
package org.dataloader.impl;
+import org.dataloader.Internal;
+
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
@@ -9,6 +11,7 @@
/**
* Some really basic helpers when working with CompletableFutures
*/
+@Internal
public class CompletableFutureKit {
public static CompletableFuture failedFuture(Exception e) {
diff --git a/src/main/java/org/dataloader/impl/DefaultCacheMap.java b/src/main/java/org/dataloader/impl/DefaultCacheMap.java
index 6edd43f4..4dcddab7 100644
--- a/src/main/java/org/dataloader/impl/DefaultCacheMap.java
+++ b/src/main/java/org/dataloader/impl/DefaultCacheMap.java
@@ -17,6 +17,7 @@
package org.dataloader.impl;
import org.dataloader.CacheMap;
+import org.dataloader.Internal;
import java.util.HashMap;
import java.util.Map;
@@ -29,6 +30,7 @@
*
* @author Arnold Schrijver
*/
+@Internal
public class DefaultCacheMap implements CacheMap {
private Map cache;
diff --git a/src/main/java/org/dataloader/impl/PromisedValues.java b/src/main/java/org/dataloader/impl/PromisedValues.java
index 840cf83e..0f992f8e 100644
--- a/src/main/java/org/dataloader/impl/PromisedValues.java
+++ b/src/main/java/org/dataloader/impl/PromisedValues.java
@@ -1,5 +1,7 @@
package org.dataloader.impl;
+import org.dataloader.Internal;
+
import java.util.List;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletableFuture;
@@ -22,6 +24,7 @@
*
* @author Brad Baker
*/
+@Internal
public interface PromisedValues {
/**
diff --git a/src/main/java/org/dataloader/impl/PromisedValuesImpl.java b/src/main/java/org/dataloader/impl/PromisedValuesImpl.java
index 5aff66e4..6c7ee496 100644
--- a/src/main/java/org/dataloader/impl/PromisedValuesImpl.java
+++ b/src/main/java/org/dataloader/impl/PromisedValuesImpl.java
@@ -1,5 +1,7 @@
package org.dataloader.impl;
+import org.dataloader.Internal;
+
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@@ -13,6 +15,7 @@
import static org.dataloader.impl.Assertions.assertState;
import static org.dataloader.impl.Assertions.nonNull;
+@Internal
public class PromisedValuesImpl implements PromisedValues {
private final List extends CompletionStage> futures;
diff --git a/src/main/java/org/dataloader/stats/Statistics.java b/src/main/java/org/dataloader/stats/Statistics.java
index bf8da1a8..6e0d102d 100644
--- a/src/main/java/org/dataloader/stats/Statistics.java
+++ b/src/main/java/org/dataloader/stats/Statistics.java
@@ -1,11 +1,14 @@
package org.dataloader.stats;
+import org.dataloader.PublicApi;
+
import java.util.LinkedHashMap;
import java.util.Map;
/**
* This holds statistics on how a {@link org.dataloader.DataLoader} has performed
*/
+@PublicApi
public class Statistics {
private final long loadCount;
diff --git a/src/main/java/org/dataloader/stats/StatisticsCollector.java b/src/main/java/org/dataloader/stats/StatisticsCollector.java
index 874e27b3..49c979f4 100644
--- a/src/main/java/org/dataloader/stats/StatisticsCollector.java
+++ b/src/main/java/org/dataloader/stats/StatisticsCollector.java
@@ -1,8 +1,11 @@
package org.dataloader.stats;
+import org.dataloader.PublicSpi;
+
/**
* This allows statistics to be collected for {@link org.dataloader.DataLoader} operations
*/
+@PublicSpi
public interface StatisticsCollector {
/**
diff --git a/src/test/java/org/dataloader/DataLoaderRegistryTest.java b/src/test/java/org/dataloader/DataLoaderRegistryTest.java
index c0a7bf7f..cd33ae3e 100644
--- a/src/test/java/org/dataloader/DataLoaderRegistryTest.java
+++ b/src/test/java/org/dataloader/DataLoaderRegistryTest.java
@@ -1,9 +1,10 @@
package org.dataloader;
-import java.util.concurrent.CompletableFuture;
import org.dataloader.stats.Statistics;
import org.junit.Test;
+import java.util.concurrent.CompletableFuture;
+
import static java.util.Arrays.asList;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasItems;
@@ -131,4 +132,28 @@ public void computeIfAbsent_returns_an_existing_data_loader_if_there_was_a_value
assertThat(registry.getDataLoaders(), hasItems(dlA));
}
+ @Test
+ public void dispatch_counts_are_maintained() {
+
+ DataLoaderRegistry registry = new DataLoaderRegistry();
+
+ DataLoader dlA = new DataLoader<>(identityBatchLoader);
+ DataLoader dlB = new DataLoader<>(identityBatchLoader);
+
+ registry.register("a", dlA);
+ registry.register("b", dlB);
+
+ dlA.load("av1");
+ dlA.load("av2");
+ dlB.load("bv1");
+ dlB.load("bv2");
+
+ int dispatchDepth = registry.dispatchDepth();
+ assertThat(dispatchDepth, equalTo(4));
+
+ int dispatchedCount = registry.dispatchAllWithCount();
+ dispatchDepth = registry.dispatchDepth();
+ assertThat(dispatchedCount, equalTo(4));
+ assertThat(dispatchDepth, equalTo(0));
+ }
}
diff --git a/src/test/java/org/dataloader/DataLoaderTest.java b/src/test/java/org/dataloader/DataLoaderTest.java
index 6c4a07d7..0718225e 100644
--- a/src/test/java/org/dataloader/DataLoaderTest.java
+++ b/src/test/java/org/dataloader/DataLoaderTest.java
@@ -110,10 +110,11 @@ public void should_Return_zero_entries_dispatched_when_no_keys_supplied() {
assertThat(promisedValues.size(), is(0));
success.set(true);
});
- DataLoaderHelper.DispatchResult dispatchResult = identityLoader.dispatchWithCounts();
+ DispatchResult dispatchResult = identityLoader.dispatchWithCounts();
await().untilAtomic(success, is(true));
- assertThat(dispatchResult.totalEntriesHandled, equalTo(0));
+ assertThat(dispatchResult.getKeysCount(), equalTo(0));
}
+
@Test
public void should_Batch_multiple_requests() throws ExecutionException, InterruptedException {
List> loadCalls = new ArrayList<>();
@@ -126,7 +127,8 @@ public void should_Batch_multiple_requests() throws ExecutionException, Interrup
await().until(() -> future1.isDone() && future2.isDone());
assertThat(future1.get(), equalTo(1));
assertThat(future2.get(), equalTo(2));
- assertThat(loadCalls, equalTo(singletonList(asList(1, 2)))); }
+ assertThat(loadCalls, equalTo(singletonList(asList(1, 2))));
+ }
@Test
public void should_Return_number_of_batched_entries() throws ExecutionException, InterruptedException {
@@ -134,11 +136,13 @@ public void should_Return_number_of_batched_entries() throws ExecutionException,
DataLoader identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
CompletableFuture future1 = identityLoader.load(1);
+ CompletableFuture future1a = identityLoader.load(1);
CompletableFuture future2 = identityLoader.load(2);
- DataLoaderHelper.DispatchResult dispatchResult = identityLoader.dispatchWithCounts();
+ DispatchResult> dispatchResult = identityLoader.dispatchWithCounts();
await().until(() -> future1.isDone() && future2.isDone());
- assertThat(dispatchResult.totalEntriesHandled, equalTo(2));
+ assertThat(dispatchResult.getKeysCount(), equalTo(2)); // its two because its the number dispatched (by key) not the load calls
+ assertThat(dispatchResult.getPromisedResults().isDone(), equalTo(true));
}
@Test