@Override protected Promise<? extends T> run(final Context context) throws Exception { final SettablePromise<T> result = Promises.settable(); Task<?> prevTask = _tasks.get(0); for (int i = 1; i < _tasks.size(); i++) { final Task<?> currTask = _tasks.get(i); context.after(prevTask).run(currTask); prevTask = currTask; } // This is unsafe, but we don't have the ability to do type checking // with varargs. @SuppressWarnings("unchecked") final Task<T> typedPrevTask = (Task<T>) prevTask; Promises.propagateResult(typedPrevTask, result); context.run(_tasks.get(0)); _tasks = null; return result; } }
@Override public Promise<String> run(final Context context) throws Exception { context.run(predecessorTask); context.after(predecessorTask).run(successorTask); return successorTask; } };
return async(desc, context -> { final SettablePromise<R> result = Promises.settable(); context.after(that).run(task); Promises.propagateResult(task, result); context.run(that);
@Override public Promise<Queue<Integer>> run(final Context context) throws Exception { final SettablePromise<Queue<Integer>> promise = Promises.settable(); final Queue<Integer> queue = new LinkedList<Integer>(); final Task<?> t1 = enqueueTask(queue, 1); t1.setPriority(-5); final Task<?> t2 = enqueueTask(queue, 2); t2.setPriority(10); final Task<?> t3 = enqueueTask(queue, 3); t3.setPriority(0); context.run(t1, t2, t3); context.after(t1, t2, t3).run(Task.action("done", () -> promise.done(queue))); return promise; } };
Task<R> flattenTask = async(desc, context -> { final SettablePromise<R> result = Promises.settable(); context.after(task).run(() -> { try { if (!task.isFailed()) {
return Task.async(desc, context -> { final SettablePromise<T> result = Promises.settable(); context.after(that).run(() -> { if (that.isFailed()) { if (!(Exceptions.isCancellation(that.getError()))) {
@Override public Promise<int[]> run(final Context ctx) { if (_range.size() == 0) { return Promises.value(new int[0]); } else if (_range.size() == 1) { return Promises.value(new int[] {_toSort[_range.start()]}); } else { // Neither base case applied, so recursively split this problem into // smaller problems and then merge the results. final Range fstRange = _range.firstHalf(); final Range sndRange = _range.secondHalf(); final Task<int[]> fst = new MergeSortPlan(_toSort, fstRange); final Task<int[]> snd = new MergeSortPlan(_toSort, sndRange); final Task<int[]> merge = mergePlan(fstRange, fst, sndRange, snd); ctx.after(fst, snd).run(merge); ctx.run(fst, snd); return merge; } }
}); context.after(that).run(sideEffectWrapper); context.run(that); return sideEffectWrapper;
/** Create a wrapped task with associated recovery task that will retry if necessary. */ private Task<T> wrap(int attempt) { Task<T> retryTask = Task.async(_policy.getName() + ", attempt " + attempt, context -> { final SettablePromise<T> result = Promises.settable(); Task<T> task = _taskFunction.apply(attempt); final Task<T> recovery = Task.async(_name + " recovery", recoveryContext -> { final SettablePromise<T> recoveryResult = Promises.settable(); if (task.isFailed()) { // Failed task will cause retry to be scheduled. ErrorClassification errorClassification = _policy.getErrorClassifier().apply(task.getError()); retry(attempt + 1, task.getError(), errorClassification, recoveryContext, recoveryResult); } else { recoveryResult.done(task.get()); } return recoveryResult; }); // Recovery task should run immediately after the original task to process its error. recovery.setPriority(Priority.MAX_PRIORITY); recovery.getShallowTraceBuilder().setSystemHidden(true); Promises.propagateResult(recovery, result); context.after(task).run(recovery); context.run(task); return result; }); retryTask.getShallowTraceBuilder().setTaskType(TaskType.RETRY.getName()); return retryTask; }
@Override protected Promise<? extends T> run(final Context context) throws Throwable { final SettablePromise<T> result = Promises.settable(); String baseName = getName(); if (_asyncTask == null) { /* There is no async predecessor, run propagation immediately */ FusionTraceContext traceContext = new FusionTraceContext(context, FusionTask.this.getShallowTraceBuilder(), baseName); propagate(traceContext, result); } else { /* There is async predecessor, need to run it first PropagationTask will actually run propagation */ final Task<T> propagationTask = Task.async(baseName, ctx -> { final SettablePromise<T> fusionResult = Promises.settable(); FusionTraceContext traceContext = new FusionTraceContext(ctx, FusionTask.this.getShallowTraceBuilder(), baseName); propagate(traceContext, fusionResult); return fusionResult; }); propagationTask.getShallowTraceBuilder() .setHidden(_shallowTraceBuilder.getHidden()) .setSystemHidden(_shallowTraceBuilder.getSystemHidden()); _shallowTraceBuilder.setName("async fused"); _shallowTraceBuilder.setSystemHidden(true); context.after(_asyncTask).run(propagationTask); context.run(_asyncTask); Promises.propagateResult(propagationTask, result); } return result; } }
recovery.getShallowTraceBuilder().setTaskType(TaskType.RECOVER.getName()); Promises.propagateResult(recovery, result); context.after(that).run(recovery); context.run(that); return result;
@Override protected Promise<? extends T> run(final Context context) throws Exception { final SettablePromise<T> result = Promises.settable(); Task<?> prevTask = _tasks.get(0); for (int i = 1; i < _tasks.size(); i++) { final Task<?> currTask = _tasks.get(i); context.after(prevTask).run(currTask); prevTask = currTask; } // This is unsafe, but we don't have the ability to do type checking // with varargs. @SuppressWarnings("unchecked") final Task<T> typedPrevTask = (Task<T>) prevTask; Promises.propagateResult(typedPrevTask, result); context.run(_tasks.get(0)); _tasks = null; return result; } }
return async(desc, context -> { final SettablePromise<R> result = Promises.settable(); context.after(that).run(task); Promises.propagateResult(task, result); context.run(that);
/** * Performs three "slow" tasks and collects the results. This uses the passed context * parameter to execute tasks. The position of the context argument is arbitrary. * * @return concatenation of binary representation of a, all caps of b, and string value * of c */ @Action(name = "parseq") public Promise<String> parseqAction(@ActionParam("a") final int a, @ActionParam("b") final String b, @ParSeqContextParam com.linkedin.parseq.Context ctx, @ActionParam("c") final boolean c) { final Task<String> t1 = makeTaskA(a); final Task<String> t2 = makeTaskB(b); final Task<String> t3 = makeTaskC(c); final Task<String> collect = makeConcatTask(t1, t2, t3); ctx.after(t1, t2, t3).run(collect); ctx.run(t1, t2, t3); return collect; }
Task<R> flattenTask = async(desc, context -> { final SettablePromise<R> result = Promises.settable(); context.after(task).run(() -> { try { if (!task.isFailed()) {
return Task.async(desc, context -> { final SettablePromise<T> result = Promises.settable(); context.after(that).run(() -> { if (that.isFailed()) { if (!(Exceptions.isCancellation(that.getError()))) {
}); context.after(that).run(sideEffectWrapper); context.run(that); return sideEffectWrapper;
/** Create a wrapped task with associated recovery task that will retry if necessary. */ private Task<T> wrap(int attempt) { Task<T> retryTask = Task.async(_policy.getName() + ", attempt " + attempt, context -> { final SettablePromise<T> result = Promises.settable(); Task<T> task = _taskFunction.apply(attempt); final Task<T> recovery = Task.async(_name + " recovery", recoveryContext -> { final SettablePromise<T> recoveryResult = Promises.settable(); if (task.isFailed()) { // Failed task will cause retry to be scheduled. ErrorClassification errorClassification = _policy.getErrorClassifier().apply(task.getError()); retry(attempt + 1, task.getError(), errorClassification, recoveryContext, recoveryResult); } else { recoveryResult.done(task.get()); } return recoveryResult; }); // Recovery task should run immediately after the original task to process its error. recovery.setPriority(Priority.MAX_PRIORITY); recovery.getShallowTraceBuilder().setSystemHidden(true); Promises.propagateResult(recovery, result); context.after(task).run(recovery); context.run(task); return result; }); retryTask.getShallowTraceBuilder().setTaskType(TaskType.RETRY.getName()); return retryTask; }
@Override protected Promise<? extends T> run(final Context context) throws Throwable { final SettablePromise<T> result = Promises.settable(); String baseName = getName(); if (_asyncTask == null) { /* There is no async predecessor, run propagation immediately */ FusionTraceContext traceContext = new FusionTraceContext(context, FusionTask.this.getShallowTraceBuilder(), baseName); propagate(traceContext, result); } else { /* There is async predecessor, need to run it first PropagationTask will actually run propagation */ final Task<T> propagationTask = Task.async(baseName, ctx -> { final SettablePromise<T> fusionResult = Promises.settable(); FusionTraceContext traceContext = new FusionTraceContext(ctx, FusionTask.this.getShallowTraceBuilder(), baseName); propagate(traceContext, fusionResult); return fusionResult; }); propagationTask.getShallowTraceBuilder() .setHidden(_shallowTraceBuilder.getHidden()) .setSystemHidden(_shallowTraceBuilder.getSystemHidden()); _shallowTraceBuilder.setName("async fused"); _shallowTraceBuilder.setSystemHidden(true); context.after(_asyncTask).run(propagationTask); context.run(_asyncTask); Promises.propagateResult(propagationTask, result); } return result; } }