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> 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