return apply(desc, (src, dst) -> { final Try<T> tryT = Promises.toTry(src); if (tryT.isFailed() && Exceptions.isCancellation(tryT.getError())) { dst.fail(src.getError()); } else { try { final Try<R> tryR = func.apply(tryT); if (tryR.isFailed()) { dst.fail(tryR.getError()); } else { dst.done(tryR.get());
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; } }); }
@Test public void testTransformFailureToSuccess() { Task<String> failure = getFailureTask(); Task<String> transformed = failure.transform(tryT -> Success.of(tryT.getError().toString() + "transformed")); runAndWait("AbstractTaskTest.testTransformFailureToSuccess", transformed); assertEquals(transformed.get(), failure.getError().toString() + "transformed"); }
@Test public void testTransformSuccessToSuccess() { Task<String> success = getSuccessTask(); Task<String> transformed = success.transform(tryT -> Success.of(tryT.get() + "transformed")); runAndWait("AbstractTaskTest.testTransformSuccessToSuccess", transformed); assertEquals(transformed.get(), success.get() + "transformed"); }
@Test public void testError() throws InterruptedException { @SuppressWarnings("unused") final Task<Try<String>> task = Task.callable("test", () -> { if (true) { throw new RuntimeException("boom"); } return "hello"; } ).toTry(); runAndWait("TestWithTry.testError", task); assertTrue(task.get().isFailed()); assertTrue(task.get().getError() instanceof RuntimeException); assertEquals(task.get().getError().getMessage(), "boom"); }
@Override protected void executeBatchWithContext(final G group, final Batch<K, T> batch, final Context ctx) { Task<Map<K, Try<T>>> task = taskForBatch(group, batch.keys()); Task<Map<K, Try<T>>> completing = task.andThen("completePromises", map -> { batch.foreach((key, promise) -> { Try<T> result = map.get(key); if (result != null) { if (result.isFailed()) { promise.fail(result.getError()); } else { promise.done(result.get()); } } else { promise.fail(new Exception("Result for key: " + key + " not found in batch response")); } }); }); completing.getShallowTraceBuilder().setSystemHidden(true); Task<Map<K, Try<T>>> withFailureHandling = completing.onFailure("handleFailures", t -> { batch.failAll(t); }); withFailureHandling.getShallowTraceBuilder().setSystemHidden(true); ctx.run(withFailureHandling); }
public void testToTry(int expectedNumberOfTasks) { Task<Try<Integer>> success = getSuccessTask().map("strlen", String::length).toTry(); runAndWait("AbstractTaskTest.testToTrySuccess", success); assertFalse(success.get().isFailed()); assertEquals((int) success.get().get(), TASK_VALUE.length()); assertEquals(countTasks(success.getTrace()), expectedNumberOfTasks); Task<Try<Integer>> failure = getFailureTask().map("strlen", String::length).toTry(); runAndWait("AbstractTaskTest.testToTryFailure", failure); assertTrue(failure.get().isFailed()); assertEquals(failure.get().getError().getMessage(), TASK_ERROR_MESSAGE); assertEquals(countTasks(failure.getTrace()), expectedNumberOfTasks); }
return apply(desc, (src, dst) -> { final Try<T> tryT = Promises.toTry(src); if (tryT.isFailed() && Exceptions.isCancellation(tryT.getError())) { dst.fail(src.getError()); } else { try { final Try<R> tryR = func.apply(tryT); if (tryR.isFailed()) { dst.fail(tryR.getError()); } else { dst.done(tryR.get());
@Override protected void executeBatchWithContext(final G group, final Batch<K, T> batch, final Context ctx) { Task<Map<K, Try<T>>> task = taskForBatch(group, batch.keys()); Task<Map<K, Try<T>>> completing = task.andThen("completePromises", map -> { batch.foreach((key, promise) -> { Try<T> result = map.get(key); if (result != null) { if (result.isFailed()) { promise.fail(result.getError()); } else { promise.done(result.get()); } } else { promise.fail(new Exception("Result for key: " + key + " not found in batch response")); } }); }); completing.getShallowTraceBuilder().setSystemHidden(true); Task<Map<K, Try<T>>> withFailureHandling = completing.onFailure("handleFailures", t -> { batch.failAll(t); }); withFailureHandling.getShallowTraceBuilder().setSystemHidden(true); ctx.run(withFailureHandling); }