Fix default values for cancelOnTimeout in DependentPromise.onTimeout overloads

Author: vsilaev

src/main/java/net/tascalate/concurrent/DependentPromise.java

@@ -228,19 +228,19 @@ public DependentPromise<T> onTimeout(T value, Duration duration, boolean cancelO
     }
 
     public DependentPromise<T> onTimeout(T value, Duration duration, boolean cancelOnTimeout, boolean enlistOrigin) {
-        return onTimeout(() -> value, duration, enlistOrigin); 
+        return onTimeout(() -> value, duration, cancelOnTimeout, enlistOrigin); 
     }
 
     public DependentPromise<T> onTimeout(Supplier<? extends T> supplier, long timeout, TimeUnit unit) {
         return onTimeout(supplier, timeout, unit, true);
     }
 
     public DependentPromise<T> onTimeout(Supplier<? extends T> supplier, long timeout, TimeUnit unit, boolean cancelOnTimeout) {
-        return onTimeout(supplier, Timeouts.toDuration(timeout, unit), false);
+        return onTimeout(supplier, Timeouts.toDuration(timeout, unit), cancelOnTimeout);
     }
 
     public DependentPromise<T> onTimeout(Supplier<? extends T> supplier, long timeout, TimeUnit unit, boolean cancelOnTimeout, boolean enlistOrigin) {
-        return onTimeout(supplier, Timeouts.toDuration(timeout, unit), enlistOrigin);
+        return onTimeout(supplier, Timeouts.toDuration(timeout, unit), cancelOnTimeout, enlistOrigin);
     }
 
     public DependentPromise<T> onTimeout(Supplier<? extends T> supplier, Duration duration) {

src/main/java/net/tascalate/concurrent/RetryPolicy.java

@@ -87,7 +87,7 @@ public final RetryPolicy retryOn(Class<? extends Throwable>... retryOnThrowables
         return retryOn(Arrays.asList(retryOnThrowables));
     }
 
-    public final RetryPolicy retryOn(Collection<Class<? extends Throwable>> retryOnThrowables) {
+    public RetryPolicy retryOn(Collection<Class<? extends Throwable>> retryOnThrowables) {
         return new RetryPolicy(maxRetries, setPlusElems(retryOn, retryOnThrowables), abortOn, retryPredicate, abortPredicate, backoff, timeout);
     }
 
@@ -96,7 +96,7 @@ public final RetryPolicy abortOn(Class<? extends Throwable>... abortOnThrowables
         return abortOn(Arrays.asList(abortOnThrowables));
     }
 
-    public final RetryPolicy abortOn(Collection<Class<? extends Throwable>> abortOnThrowables) {
+    public RetryPolicy abortOn(Collection<Class<? extends Throwable>> abortOnThrowables) {
         return new RetryPolicy(maxRetries, retryOn, setPlusElems(abortOn, abortOnThrowables), retryPredicate, abortPredicate, backoff, timeout);
     }
 

src/main/java/net/tascalate/concurrent/Timeouts.java

@@ -1,3 +1,18 @@
+/**
+ * Copyright 2015-2017 Valery Silaev (http://vsilaev.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package net.tascalate.concurrent;
 
 import java.time.Duration;

src/test/java/net/tascalate/concurrent/J8Examples.java

@@ -25,13 +25,30 @@ public class J8Examples {
     public static void main(final String[] argv) throws InterruptedException, ExecutionException {
         final TaskExecutorService executorService = TaskExecutors.newFixedThreadPool(3);
 
-        Promises.success("ABC").applyToEither(Promises.failure(new IllegalArgumentException()),r -> {
-           System.out.println("Race won by value: " + r);
-           return r;
-        });
+
+        Promise<String> poller = Promises.poll(
+            J8Examples::pollingMethod, executorService, 
+            RetryPolicy.DEFAULT
+            .withMaxRetries(10)
+            .withTimeout(DelayPolicy.fixedInterval(3200))
+            .withBackoff(DelayPolicy.fixedInterval(200).withMinDelay(100).withFirstRetryNoDelay())
+        );
+        
+        System.out.println("Poller: " + poller.get());
+
+        CompletableTask
+        .delay( Duration.ofMillis(100), executorService )
+        .thenRun(() -> System.out.println("After initial delay"));
+
 
         CompletableTask
             .supplyAsync(() -> awaitAndProduceN(73), executorService)
+            .dependent()
+            .delay( Duration.ofMillis(100), true, true )
+            .thenApply(v -> {
+                System.out.println("After delay: " + v);
+                return v;
+            }, true)
             .onTimeout(123456789, Duration.ofMillis(200))
             .thenAcceptAsync(J8Examples::onComplete)
             .get(); 
@@ -127,7 +144,7 @@ private static int awaitAndProduce2(int i) {
     private static int awaitAndProduceN(int i) {
         try {
             System.out.println("Delay N + " + i + " in " + Thread.currentThread());
-            Thread.sleep(500);
+            Thread.sleep(1500);
             if (i % 2 == 0) {
                 throw new RuntimeException("Even value: " + i);
             }
@@ -139,6 +156,24 @@ private static int awaitAndProduceN(int i) {
         }
     }
 
+    private static String pollingMethod() throws InterruptedException {
+        RetryContext ctx = RetryContext.current();
+        System.out.println("Polling method, #" + ctx.getRetryCount());
+        try {
+            if (ctx.getRetryCount() < 5) {
+                Thread.sleep((5 - ctx.getRetryCount()) * 1000);
+            }
+            if (ctx.getRetryCount() < 7) {
+                throw new IllegalStateException();
+            }
+            return "Result " + ctx.getRetryCount();
+        } catch (final InterruptedException ex) {
+            System.out.println("Polling method, #" + ctx.getRetryCount() + ", interrupted!");
+            Thread.currentThread().interrupt();
+            throw ex;
+        }
+    }
+    
     private static void onComplete(int i) {
         System.out.println(">>> Result " + i + ", " + Thread.currentThread());
     }