private <T> Task<Response<T>> withD2Timeout(final Task<Response<T>> task, ConfigValue<Long> timeout) { String srcDesc = timeout.getSource().map(src -> " src: " + src).orElse(""); String timeoutTaskName = "withTimeout " + timeout.getValue().intValue() + TimeUnitHelper.toString(TimeUnit.MILLISECONDS) + srcDesc; // make sure that we throw the same exception to maintain backward compatibility with current withTimeout implementation. return task.transform(timeoutTaskName, (Try<Response<T>> tryGet) -> { if (tryGet.isFailed() && tryGet.getError() instanceof TimeoutException) { String timeoutExceptionMessage = "task: '" + task.getName() + "' " + timeoutTaskName; return Failure.of(Exceptions.timeoutException(timeoutExceptionMessage)); } else { return tryGet; } }); }
public static <R> Try<R> of(Throwable t) { return new Failure<R>(t); }
/** * Returns instance of {@link Try} that represents result a promise has completed with. * This method throws {@link PromiseUnresolvedException} if teh promise has not been resolved yet. * * @return instance of {@link Try} that represents result the promise has completed with * @see Try */ public static <T> Try<T> toTry(final Promise<T> promise) { if (promise.isFailed()) { return Failure.of(promise.getError()); } else { return Success.of(promise.get()); } }
public static <R> Try<R> of(Throwable t) { return new Failure<R>(t); }
@Test public void testTransformFailureToFailure() { Task<String> failure = getFailureTask(); final Exception failureReason = new Exception(); Task<String> transformed = failure.transform(tryT -> Failure.of(failureReason)); try { runAndWait("AbstractTaskTest.testTransformFailureToFailure", transformed); fail("should have failed"); } catch (Exception ex) { assertTrue(transformed.isFailed()); } assertSame(transformed.getError(), failureReason); }
@Test public void testTransformSuccessToFailure() { Task<String> success = getSuccessTask(); final Exception failureReason = new Exception(); Task<String> transformed = success.transform(tryT -> Failure.of(failureReason)); try { runAndWait("AbstractTaskTest.testTransformSuccessToSuccess", transformed); fail("should have failed"); } catch (Exception ex) { assertTrue(transformed.isFailed()); } assertSame(transformed.getError(), failureReason); }
@Test public void testFailureReturned() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> { if (key % 2 == 1) { return Failure.of(new Exception("failure message")); } else { return Success.of(String.valueOf(key)); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).recover(e -> e.getMessage()), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testFailureReturned", task); assertEquals(result, "0failure message2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchAndFailedSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> { if (key % 2 == 0) { return Success.of(String.valueOf(key)); } else { return Failure.of(new Exception()); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).recover(e -> "failed"), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testBatchAndFailedSingleton", task); assertEquals(result, "0failed2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testFailedBatchAndSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> { if (key % 2 == 1) { return Success.of(String.valueOf(key)); } else { return Failure.of(new Exception()); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1), strategy.batchable(2).recover(e -> "failed")) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testFailedBatchAndSingleton", task); assertEquals(result, "failed1failed"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
/** * Returns instance of {@link Try} that represents result a promise has completed with. * This method throws {@link PromiseUnresolvedException} if teh promise has not been resolved yet. * * @return instance of {@link Try} that represents result the promise has completed with * @see Try */ public static <T> Try<T> toTry(final Promise<T> promise) { if (promise.isFailed()) { return Failure.of(promise.getError()); } else { return Success.of(promise.get()); } }